Немного об отладке. Часть 2

/* https://github.com/microsoft/MIEngine/blob/7a111c9fe46107969b4ffa674df059def7124364/src/OpenDebugAD7/AD7DebugSession.cs#L1104 */ internal sealed class AD7DebugSession {     private IDebugEngineLaunch2 m_engineLaunch;     protected override void HandleLaunchRequestAsync(IRequestResponder<LaunchArguments> responder)     {         /* ... */         hr = m_engineLaunch.LaunchSuspended(null,             m_port,             program,             null,             null,             null,             launchJson,             flags,             0,             0,             0,             this,             out m_process);          hr = m_engineLaunch.ResumeProcess(m_process);         /* ... */     }     /* ... */ }  sealed public class AE7Engine {     /* https://github.com/microsoft/MIEngine/blob/7a111c9fe46107969b4ffa674df059def7124364/src/MIDebugEngine/AD7.Impl/AD7Engine.cs#L534 */     int IDebugEngineLaunch2.LaunchSuspended(string pszServer, IDebugPort2 port, string exe, string args, string dir, string env, string options, enum_LAUNCH_FLAGS launchFlags, uint hStdInput, uint hStdOutput, uint hStdError, IDebugEventCallback2 ad7Callback, out IDebugProcess2 process)     {         /* ... */         StartDebugging(launchOptions);         /* ... */     }      /* https://github.com/microsoft/MIEngine/blob/7a111c9fe46107969b4ffa674df059def7124364/src/MIDebugEngine/AD7.Impl/AD7Engine.cs#L575 */     private void StartDebugging(LaunchOptions launchOptions)     {         /* ... */         _pollThread = new WorkerThread(Logger);         var cancellationTokenSource = new CancellationTokenSource();          using (cancellationTokenSource)         {             _pollThread.RunOperation(ResourceStrings.InitializingDebugger, cancellationTokenSource, (HostWaitLoop waitLoop) =>             {                     _debuggedProcess = new DebuggedProcess(true, launchOptions, _engineCallback, _pollThread, _breakpointManager, this, _configStore, waitLoop);                  return _debuggedProcess.Initialize(waitLoop, cancellationTokenSource.Token);             });         }         /* ... */     } }  internal class DebuggedProcess : MICore.Debugger {     /* https://github.com/microsoft/MIEngine/blob/7a111c9fe46107969b4ffa674df059def7124364/src/MIDebugEngine/Engine.Impl/DebuggedProcess.cs#L544 */     public async Task Initialize(HostWaitLoop waitLoop, CancellationToken token)     {         /* ... */         List<LaunchCommand> commands = await GetInitializeCommands();         _childProcessHandler?.Enable();          total = commands.Count;         var i = 0;         foreach (var command in commands)         {             token.ThrowIfCancellationRequested();             waitLoop.SetProgress(total, i++, command.Description);             if (command.IsMICommand)             {                 Results results = await CmdAsync(command.CommandText, ResultClass.None);             }             else             {                 string resultString = await ConsoleCmdAsync(command.CommandText, allowWhileRunning: false, ignoreFailures: command.IgnoreFailures);             }         }         /* ... */     } } 

internal class DebuggedProcess : MIcore.Debugger {     /* https://github.com/microsoft/MIEngine/blob/7a111c9fe46107969b4ffa674df059def7124364/src/MIDebugEngine/Engine.Impl/DebuggedProcess.cs#L618 */     private async Task<List<LaunchCommand>> GetInitializeCommands()     {         List<LaunchCommand> commands = new List<LaunchCommand>();          commands.AddRange(_launchOptions.SetupCommands);          if (_launchOptions.DebuggerMIMode == MIMode.Gdb)         {             commands.Add(new LaunchCommand("-interpreter-exec console \"set pagination off\""));         }          commands.Add(new LaunchCommand("-gdb-set auto-solib-add " + (_launchOptions.CanAutoLoadSymbols() ? "on" : "off")));          if (!string.IsNullOrEmpty(_launchOptions.AbsolutePrefixSOLibSearchPath))         {             commands.Add(new LaunchCommand("-gdb-set solib-absolute-prefix " + _launchOptions.AbsolutePrefixSOLibSearchPath));         }          // On Windows ';' appears to correctly works as a path seperator and from the documentation, it is ':' on unix or cygwin envrionments         string pathEntrySeperator = (_launchOptions.UseUnixSymbolPaths || IsCygwin) ? ":" : ";";         string escapedSearchPath = string.Join(pathEntrySeperator, _launchOptions.GetSOLibSearchPath().Select(path => {             return EnsureProperPathSeparators(path, ignoreSpaces: true);         }));         if (!string.IsNullOrWhiteSpace(escapedSearchPath))         {             if (_launchOptions.DebuggerMIMode == MIMode.Gdb)             {                 // Do not place quotes around so paths for gdb                 commands.Add(new LaunchCommand("-gdb-set solib-search-path " + escapedSearchPath + pathEntrySeperator, ResourceStrings.SettingSymbolSearchPath));             }             else             {                 // surround so lib path with quotes in other cases                 commands.Add(new LaunchCommand("-gdb-set solib-search-path \"" + escapedSearchPath + pathEntrySeperator + "\"", ResourceStrings.SettingSymbolSearchPath));             }         }          if (MICommandFactory.SupportsChildProcessDebugging())         {             if (_launchOptions.DebugChildProcesses)             {                 _childProcessHandler = new DebugUnixChild(this, this._launchOptions);             }         }          LocalLaunchOptions localLaunchOptions = _launchOptions as LocalLaunchOptions;         if (this.IsCoreDump)         {             // Load executable and core dump             this.AddExecutableAndCorePathCommand(commands);              // Important: this must occur after executable load but before anything else.             this.AddGetTargetArchitectureCommand(commands);         }         /* ... */     } } 

Это дизассемблированные исходники

public abstract class DebugProtocol {     internal void SendMessageCore(ProtocolMessage message)     {         if (message.Seq == 0)         {             message.Seq = GetNextSequenceNumber();         }          TraceMessage(message, null, isSend: true);         string s = JsonConvert.SerializeObject(message, jsonSettings);         byte[] bytes = ProtocolEncoding.GetBytes(s);         string s2 = "Content-Length: {0}\r\n\r\n".FormatInvariantWithArgs(bytes.Length);         byte[] bytes2 = ProtocolEncoding.GetBytes(s2);         byte[] array = new byte[bytes2.Length + bytes.Length];         Buffer.BlockCopy(bytes2, 0, array, 0, bytes2.Length);         Buffer.BlockCopy(bytes, 0, array, bytes2.Length, bytes.Length);         lock (outgoingSyncObj)         {             outgoingQueue.Enqueue(array);             if (!isSendingMessages)             {                 isSendingMessages = true;                 messagesPendingEvent.Reset();                 Task.Run(delegate                 {                     SendQueuedMessages();                 });             }         }     } } 

public abstract class DebugAdapterBase {     protected virtual ResponseBody HandleProtocolRequest(string requestType, object requestArgs)     {         return requestType switch         {             "addBreakpoint" => HandleAddBreakpointRequest((AddBreakpointArguments)requestArgs),             "addFavorite" => HandleAddFavoriteRequest((AddFavoriteArguments)requestArgs),             "attach" => HandleAttachRequest((AttachArguments)requestArgs),             "breakpointLocations" => HandleBreakpointLocationsRequest((BreakpointLocationsArguments)requestArgs),             "cancel" => HandleCancelRequest((CancelArguments)requestArgs),             "completions" => HandleCompletionsRequest((CompletionsArguments)requestArgs),             "configurationDone" => HandleConfigurationDoneRequest((ConfigurationDoneArguments)requestArgs),             "continue" => HandleContinueRequest((ContinueArguments)requestArgs),             "createObjectId" => HandleCreateObjectIdRequest((CreateObjectIdArguments)requestArgs),             "dataBreakpointInfo" => HandleDataBreakpointInfoRequest((DataBreakpointInfoArguments)requestArgs),             "destroyObjectId" => HandleDestroyObjectIdRequest((DestroyObjectIdArguments)requestArgs),             "disassemble" => HandleDisassembleRequest((DisassembleArguments)requestArgs),             "disconnect" => HandleDisconnectRequest((DisconnectArguments)requestArgs),             "evaluate" => HandleEvaluateRequest((EvaluateArguments)requestArgs),             "exceptionInfo" => HandleExceptionInfoRequest((ExceptionInfoArguments)requestArgs),             "exceptionStackTrace" => HandleExceptionStackTraceRequest((ExceptionStackTraceArguments)requestArgs),             "goto" => HandleGotoRequest((GotoArguments)requestArgs),             "gotoTargets" => HandleGotoTargetsRequest((GotoTargetsArguments)requestArgs),             "initialize" => HandleInitializeRequest((InitializeArguments)requestArgs),             "launch" => HandleLaunchRequest((LaunchArguments)requestArgs),             "loadedSources" => HandleLoadedSourcesRequest((LoadedSourcesArguments)requestArgs),             "loadSymbols" => HandleLoadSymbolsRequest((LoadSymbolsArguments)requestArgs),             "modules" => HandleModulesRequest((ModulesArguments)requestArgs),             "moduleSymbolSearchLog" => HandleModuleSymbolSearchLogRequest((ModuleSymbolSearchLogArguments)requestArgs),             "next" => HandleNextRequest((NextArguments)requestArgs),             "pause" => HandlePauseRequest((PauseArguments)requestArgs),             "readMemory" => HandleReadMemoryRequest((ReadMemoryArguments)requestArgs),             "removeBreakpoint" => HandleRemoveBreakpointRequest((RemoveBreakpointArguments)requestArgs),             "removeFavorite" => HandleRemoveFavoriteRequest((RemoveFavoriteArguments)requestArgs),             "restartFrame" => HandleRestartFrameRequest((RestartFrameArguments)requestArgs),             "restart" => HandleRestartRequest((RestartArguments)requestArgs),             "reverseContinue" => HandleReverseContinueRequest((ReverseContinueArguments)requestArgs),             "scopes" => HandleScopesRequest((ScopesArguments)requestArgs),             "setBreakpoints" => HandleSetBreakpointsRequest((SetBreakpointsArguments)requestArgs),             "setDataBreakpoints" => HandleSetDataBreakpointsRequest((SetDataBreakpointsArguments)requestArgs),             "setDebuggerProperty" => HandleSetDebuggerPropertyRequest((SetDebuggerPropertyArguments)requestArgs),             "setExceptionBreakpoints" => HandleSetExceptionBreakpointsRequest((SetExceptionBreakpointsArguments)requestArgs),             "setExpression" => HandleSetExpressionRequest((SetExpressionArguments)requestArgs),             "setFunctionBreakpoints" => HandleSetFunctionBreakpointsRequest((SetFunctionBreakpointsArguments)requestArgs),             "setHitCount" => HandleSetHitCountRequest((SetHitCountArguments)requestArgs),             "setInstructionBreakpoints" => HandleSetInstructionBreakpointsRequest((SetInstructionBreakpointsArguments)requestArgs),             "setSymbolOptions" => HandleSetSymbolOptionsRequest((SetSymbolOptionsArguments)requestArgs),             "setVariable" => HandleSetVariableRequest((SetVariableArguments)requestArgs),             "source" => HandleSourceRequest((SourceArguments)requestArgs),             "stackTrace" => HandleStackTraceRequest((StackTraceArguments)requestArgs),             "stepBack" => HandleStepBackRequest((StepBackArguments)requestArgs),             "stepIn" => HandleStepInRequest((StepInArguments)requestArgs),             "stepInTargets" => HandleStepInTargetsRequest((StepInTargetsArguments)requestArgs),             "stepOut" => HandleStepOutRequest((StepOutArguments)requestArgs),             "terminate" => HandleTerminateRequest((TerminateArguments)requestArgs),             "terminateThreads" => HandleTerminateThreadsRequest((TerminateThreadsArguments)requestArgs),             "threads" => HandleThreadsRequest((ThreadsArguments)requestArgs),             "updateBreakpoint" => HandleUpdateBreakpointRequest((UpdateBreakpointArguments)requestArgs),             "variables" => HandleVariablesRequest((VariablesArguments)requestArgs),             "vsCustomMessage" => HandleVsCustomMessageRequest((VsCustomMessageArguments)requestArgs),             "writeMemory" => HandleWriteMemoryRequest((WriteMemoryArguments)requestArgs),             _ => throw new InvalidOperationException("Unknown request type '{0}'!".FormatInvariantWithArgs(requestType)),         };     } } 

internal sealed class AD7DebugSession {     /* https://github.com/microsoft/MIEngine/blob/7a111c9fe46107969b4ffa674df059def7124364/src/OpenDebugAD7/AD7DebugSession.cs#L2349 */     protected override void HandleSetBreakpointsRequestAsync(IRequestResponder<SetBreakpointsArguments, SetBreakpointsResponse> responder)     {         string path = null;         string name = null;          if (responder.Arguments.Source != null)         {             string p = responder.Arguments.Source.Path;             if (p != null && p.Trim().Length > 0)             {                 path = p;             }             string nm = responder.Arguments.Source.Name;             if (nm != null && nm.Trim().Length > 0)             {                 name = nm;             }         }          var source = new Source()         {             Name = name,             Path = path,             SourceReference = 0         };          List<SourceBreakpoint> breakpoints = responder.Arguments.Breakpoints;          bool sourceModified = responder.Arguments.SourceModified.GetValueOrDefault(false);          string convertedPath = m_pathConverter.ConvertClientPathToDebugger(source.Path);          HashSet<int> lines = new HashSet<int>(breakpoints.Select((b) => b.Line));          Dictionary<int, IDebugPendingBreakpoint2> dict = null;         if (m_breakpoints.ContainsKey(convertedPath))         {             dict = m_breakpoints[convertedPath];             var keys = new int[dict.Keys.Count];             dict.Keys.CopyTo(keys, 0);             foreach (var l in keys)             {                 // Delete all breakpoints that are no longer listed.                 // In the case of modified source, delete everything.                 if (!lines.Contains(l) || sourceModified)                 {                     var bp = dict[l];                     bp.Delete();                     dict.Remove(l);                 }             }         }         else         {             dict = new Dictionary<int, IDebugPendingBreakpoint2>();             m_breakpoints[convertedPath] = dict;         }          foreach (var bp in breakpoints)         {             if (dict.ContainsKey(bp.Line))             {                 // already created                 IDebugBreakpointRequest2 breakpointRequest;                 if (dict[bp.Line].GetBreakpointRequest(out breakpointRequest) == 0 &&                     breakpointRequest is AD7BreakPointRequest ad7BPRequest)                 {                     // Check to see if this breakpoint has a condition that has changed.                     if (!StringComparer.Ordinal.Equals(ad7BPRequest.Condition, bp.Condition))                     {                         // Condition has been modified. Delete breakpoint so it will be recreated with the updated condition.                         var toRemove = dict[bp.Line];                         toRemove.Delete();                         dict.Remove(bp.Line);                     }                     // Check to see if tracepoint changed                     else if (!StringComparer.Ordinal.Equals(ad7BPRequest.LogMessage, bp.LogMessage))                     {                         ad7BPRequest.ClearTracepoint();                         var toRemove = dict[bp.Line];                         toRemove.Delete();                         dict.Remove(bp.Line);                     }                     else                     {                         if (ad7BPRequest.BindResult != null)                         {                             // use the breakpoint created from IDebugBreakpointErrorEvent2 or IDebugBreakpointBoundEvent2                             resBreakpoints.Add(ad7BPRequest.BindResult);                         }                         else                         {                             resBreakpoints.Add(new Breakpoint()                             {                                 Id = (int)ad7BPRequest.Id,                                 Verified = true,                                 Line = bp.Line                             });                         }                         continue;                     }                 }             }               // Create a new breakpoint             if (!dict.ContainsKey(bp.Line))             {                 IDebugPendingBreakpoint2 pendingBp;                 AD7BreakPointRequest pBPRequest = new AD7BreakPointRequest(m_sessionConfig, convertedPath, m_pathConverter.ConvertClientLineToDebugger(bp.Line), bp.Condition);                  try                 {                     bool verified = true;                     if (!string.IsNullOrEmpty(bp.LogMessage))                     {                         // Make sure tracepoint is valid.                         verified = pBPRequest.SetLogMessage(bp.LogMessage);                     }                      if (verified)                     {                         eb.CheckHR(m_engine.CreatePendingBreakpoint(pBPRequest, out pendingBp));                         eb.CheckHR(pendingBp.Bind());                          dict[bp.Line] = pendingBp;                          resBreakpoints.Add(new Breakpoint()                         {                             Id = (int)pBPRequest.Id,                             Verified = verified,                             Line = bp.Line                         });                     }                     else                     {                         resBreakpoints.Add(new Breakpoint()                         {                             Id = (int)pBPRequest.Id,                             Verified = verified,                             Line = bp.Line,                             Message = string.Format(CultureInfo.CurrentCulture, AD7Resources.Error_UnableToParseLogMessage)                         });                     }                 }                 catch (Exception e)                 {                     e = Utilities.GetInnerMost(e);                     if (Utilities.IsCorruptingException(e))                     {                         Utilities.ReportException(e);                     }                      resBreakpoints.Add(new Breakpoint()                     {                         Id = (int)pBPRequest.Id,                         Verified = false,                         Line = bp.Line,                         Message = eb.GetMessageForException(e)                     });                 }             }         }     } } 

Их 3 версии — на строку в файле, функцию и адрес инструкции.

public abstract class MICommandFactory {     /* https://github.com/microsoft/MIEngine/blob/7a111c9fe46107969b4ffa674df059def7124364/src/MICore/CommandFactories/MICommandFactory.cs#L482 */     public virtual async Task<Results> BreakInsert(string filename, bool useUnixFormat, uint line, string condition, bool enabled, IEnumerable<Checksum> checksums = null, ResultClass resultClass = ResultClass.done)     {         StringBuilder cmd = await BuildBreakInsert(condition, enabled);          if (checksums != null && checksums.Any())         {             cmd.Append(Checksum.GetMIString(checksums));             cmd.Append(' ');         }          string filenameMI;         bool quotes = PreparePath(filename, useUnixFormat, out filenameMI);         if (quotes)         {             cmd.Append('\"');         }         cmd.Append(filenameMI);         cmd.Append(':');         cmd.Append(line.ToString(CultureInfo.InvariantCulture));         if (quotes)         {             cmd.Append('\"');         }          return await _debugger.CmdAsync(cmd.ToString(), resultClass);     }      /* https://github.com/microsoft/MIEngine/blob/7a111c9fe46107969b4ffa674df059def7124364/src/MICore/CommandFactories/MICommandFactory.cs#L509 */     public virtual async Task<Results> BreakInsert(string functionName, string condition, bool enabled, ResultClass resultClass = ResultClass.done)     {         StringBuilder cmd = await BuildBreakInsert(condition, enabled);         cmd.Append(functionName);         return await _debugger.CmdAsync(cmd.ToString(), resultClass);     }      /* https://github.com/microsoft/MIEngine/blob/7a111c9fe46107969b4ffa674df059def7124364/src/MICore/CommandFactories/MICommandFactory.cs#L517 */     public virtual async Task<Results> BreakInsert(ulong codeAddress, string condition, bool enabled, ResultClass resultClass = ResultClass.done)     {         StringBuilder cmd = await BuildBreakInsert(condition, enabled);         cmd.Append('*');         cmd.Append(codeAddress);         return await _debugger.CmdAsync(cmd.ToString(), resultClass);     }      /* https://github.com/microsoft/MIEngine/blob/7a111c9fe46107969b4ffa674df059def7124364/src/MICore/CommandFactories/MICommandFactory.cs#L445 */     public virtual Task<StringBuilder> BuildBreakInsert(string condition, bool enabled)     {         StringBuilder cmd = new StringBuilder("-break-insert -f ");         if (condition != null)         {             cmd.Append("-c \"");             cmd.Append(EscapeQuotes(condition));             cmd.Append("\" ");         }         if (!enabled)         {             cmd.Append("-d ");         }         if (_debugger.LaunchOptions.RequireHardwareBreakpoints)         {             cmd.Append("-h ");         }         return Task<StringBuilder>.FromResult(cmd);     } } 

public abstract class MICommandFactory {     /* https://github.com/microsoft/MIEngine/blob/7a111c9fe46107969b4ffa674df059def7124364/src/MICore/CommandFactories/MICommandFactory.cs#L555 */     public virtual async Task BreakDelete(string bkptno, ResultClass resultClass = ResultClass.done)     {         await _debugger.CmdAsync("-break-delete " + bkptno, resultClass);     } } 

internal sealed class AD7DebugSession {     /* https://github.com/microsoft/MIEngine/blob/7a111c9fe46107969b4ffa674df059def7124364/src/OpenDebugAD7/AD7DebugSession.cs#L1576 */     protected override void HandleStepInRequestAsync(IRequestResponder<StepInArguments> responder)     {         try         {             var granularity = responder.Arguments.Granularity.GetValueOrDefault();             StepInternal(responder.Arguments.ThreadId, enum_STEPKIND.STEP_INTO, granularity, AD7Resources.Error_Scenario_Step_In);             responder.SetResponse(new StepInResponse());         }         catch (AD7Exception e)         {             responder.SetError(new ProtocolException(e.Message));         }     }      /* https://github.com/microsoft/MIEngine/blob/7a111c9fe46107969b4ffa674df059def7124364/src/OpenDebugAD7/AD7DebugSession.cs#L1590 */     protected override void HandleNextRequestAsync(IRequestResponder<NextArguments> responder)     {         try         {             var granularity = responder.Arguments.Granularity.GetValueOrDefault();             StepInternal(responder.Arguments.ThreadId, enum_STEPKIND.STEP_OVER, granularity, AD7Resources.Error_Scenario_Step_Next);             responder.SetResponse(new NextResponse());         }         catch (AD7Exception e)         {             responder.SetError(new ProtocolException(e.Message));         }     }      /* https://github.com/microsoft/MIEngine/blob/7a111c9fe46107969b4ffa674df059def7124364/src/OpenDebugAD7/AD7DebugSession.cs#L1604 */     protected override void HandleStepOutRequestAsync(IRequestResponder<StepOutArguments> responder)     {         try         {             var granularity = responder.Arguments.Granularity.GetValueOrDefault();             StepInternal(responder.Arguments.ThreadId, enum_STEPKIND.STEP_OUT, granularity, AD7Resources.Error_Scenario_Step_Out);             responder.SetResponse(new StepOutResponse());         }         catch (AD7Exception e)         {             responder.SetError(new ProtocolException(e.Message));         }     }      /* https://github.com/microsoft/MIEngine/blob/7a111c9fe46107969b4ffa674df059def7124364/src/OpenDebugAD7/AD7DebugSession.cs#L877 */     private void StepInternal(int threadId, enum_STEPKIND stepKind, SteppingGranularity granularity, string errorMessage)     {         // If we are already running ignore additional step requests         if (!m_isStopped)             return;          IDebugThread2 thread = null;         lock (m_threads)         {             if (!m_threads.TryGetValue(threadId, out thread))             {                 throw new AD7Exception(errorMessage);             }         }          ErrorBuilder builder = new ErrorBuilder(() => errorMessage);         m_isStepping = true;          enum_STEPUNIT stepUnit = enum_STEPUNIT.STEP_STATEMENT;         switch (granularity)         {             case SteppingGranularity.Statement:             default:                 break;             case SteppingGranularity.Line:                 stepUnit = enum_STEPUNIT.STEP_LINE;                 break;             case SteppingGranularity.Instruction:                 stepUnit = enum_STEPUNIT.STEP_INSTRUCTION;                 break;         }         try         {             builder.CheckHR(m_program.Step(thread, stepKind, stepUnit));         }         catch (AD7Exception)         {             m_isStopped = true;             throw;         }         // The program should now be stepping, so it is safe to discard the         // cached program state.         BeforeContinue();         m_isStepping = true;     } }  sealed public class AD7Engine {     /* https://github.com/microsoft/MIEngine/blob/7a111c9fe46107969b4ffa674df059def7124364/src/MIDebugEngine/AD7.Impl/AD7Engine.cs#L965 */     public int Step(IDebugThread2 pThread, enum_STEPKIND kind, enum_STEPUNIT unit)     {         AD7Thread thread = (AD7Thread)pThread;          try         {             if (null == thread || null == thread.GetDebuggedThread())             {                 return Constants.E_FAIL;             }              _debuggedProcess.WorkerThread.RunOperation(() => _debuggedProcess.Step(thread.GetDebuggedThread().Id, kind, unit));         }         catch (InvalidCoreDumpOperationException)         {             return AD7_HRESULT.E_CRASHDUMP_UNSUPPORTED;         }         catch (Exception e)         {             _engineCallback.OnError(EngineUtils.GetExceptionDescription(e));             return Constants.E_ABORT;         }          return Constants.S_OK;     } }  internal class DebuggedProcess {     /* https://github.com/microsoft/MIEngine/blob/7a111c9fe46107969b4ffa674df059def7124364/src/MIDebugEngine/Engine.Impl/DebuggedProcess.cs#L1725 */     public async Task Step(int threadId, enum_STEPKIND kind, enum_STEPUNIT unit)     {         this.VerifyNotDebuggingCoreDump();          await ExceptionManager.EnsureSettingsUpdated();          if ((unit == enum_STEPUNIT.STEP_LINE) || (unit == enum_STEPUNIT.STEP_STATEMENT))         {             switch (kind)             {                 case enum_STEPKIND.STEP_INTO:                     await MICommandFactory.ExecStep(threadId);                     break;                 case enum_STEPKIND.STEP_OVER:                     await MICommandFactory.ExecNext(threadId);                     break;                 case enum_STEPKIND.STEP_OUT:                     await MICommandFactory.ExecFinish(threadId);                     break;                 default:                     throw new NotImplementedException();             }         }         else if (unit == enum_STEPUNIT.STEP_INSTRUCTION)         {             switch (kind)             {                 case enum_STEPKIND.STEP_INTO:                     await MICommandFactory.ExecStepInstruction(threadId);                     break;                 case enum_STEPKIND.STEP_OVER:                     await MICommandFactory.ExecNextInstruction(threadId);                     break;                 case enum_STEPKIND.STEP_OUT:                     await MICommandFactory.ExecFinish(threadId);                     break;                 default:                     throw new NotImplementedException();             }         }         else         {             throw new NotImplementedException();         }     } }  public abstract class MICommandFactory {     /* https://github.com/microsoft/MIEngine/blob/7a111c9fe46107969b4ffa674df059def7124364/src/MICore/CommandFactories/MICommandFactory.cs#L232 */     public async Task ExecStep(int threadId, ResultClass resultClass = ResultClass.running)     {         string command = "-exec-step";         string args = string.Empty;         await ThreadFrameCmdAsync(command, args, resultClass, threadId, 0);     }      /* https://github.com/microsoft/MIEngine/blob/7a111c9fe46107969b4ffa674df059def7124364/src/MICore/CommandFactories/MICommandFactory.cs#L239 */     public async Task ExecNext(int threadId, ResultClass resultClass = ResultClass.running)     {         string command = "-exec-next";         string args = string.Empty;         await ThreadFrameCmdAsync(command, args, resultClass, threadId, 0);     }      /* https://github.com/microsoft/MIEngine/blob/7a111c9fe46107969b4ffa674df059def7124364/src/MICore/CommandFactories/MICommandFactory.cs#L246 */     public async Task ExecFinish(int threadId, ResultClass resultClass = ResultClass.running)     {         string command = "-exec-finish";         string args = string.Empty;         await ThreadFrameCmdAsync(command, args, resultClass, threadId, 0);     }      /* https://github.com/microsoft/MIEngine/blob/7a111c9fe46107969b4ffa674df059def7124364/src/MICore/CommandFactories/MICommandFactory.cs#L253 */     public async Task ExecStepInstruction(int threadId, ResultClass resultClass = ResultClass.running)     {         string command = "-exec-step-instruction";         string args = string.Empty;         await ThreadFrameCmdAsync(command, args, resultClass, threadId, 0);     }      /* https://github.com/microsoft/MIEngine/blob/7a111c9fe46107969b4ffa674df059def7124364/src/MICore/CommandFactories/MICommandFactory.cs#L260 */     public async Task ExecNextInstruction(int threadId, ResultClass resultClass = ResultClass.running)     {         string command = "-exec-next-instruction";         string args = string.Empty;         await ThreadFrameCmdAsync(command, args, resultClass, threadId, 0);     } } 

/* https://svn.code.sf.net/p/codeblocks/code/tags/20.03/src/plugins/debuggergdb/debuggergdb.cpp */ int DebuggerGDB::DoDebug(bool breakOnEntry) {     /* ... */     wxString cmdline;     if (m_PidToAttach == 0)     {         /* ... */         cmdline = m_State.GetDriver()->GetCommandLine(cmdexe, debuggee, GetActiveConfigEx().GetUserArguments());     }     else // m_PidToAttach != 0         cmdline = m_State.GetDriver()->GetCommandLine(cmdexe, m_PidToAttach, GetActiveConfigEx().GetUserArguments());      /* ... */      // start the gdb process     wxString wdir = m_State.GetDriver()->GetDebuggersWorkingDirectory();     if (wdir.empty())         wdir = m_pProject ? m_pProject->GetBasePath() : _T(".");     int ret = LaunchProcess(cmdline, wdir);     /* ... */ } // Debug  int DebuggerGDB::LaunchProcess(const wxString& cmd, const wxString& cwd) {     if (m_pProcess)         return -1;      // start the gdb process     m_pProcess = new PipedProcess(&m_pProcess, this, idGDBProcess, true, cwd);     Log(_("Starting debugger: ") + cmd);     m_Pid = LaunchProcessWithShell(cmd, m_pProcess, cwd);      if (!m_Pid)     {         delete m_pProcess;         m_pProcess = 0;         Log(_("failed"), Logger::error);         return -1;     }     else if (!m_pProcess->GetOutputStream())     {         delete m_pProcess;         m_pProcess = 0;         Log(_("failed (to get debugger's stdin)"), Logger::error);         return -2;     }     else if (!m_pProcess->GetInputStream())     {         delete m_pProcess;         m_pProcess = 0;         Log(_("failed (to get debugger's stdout)"), Logger::error);         return -2;     }     else if (!m_pProcess->GetErrorStream())     {         delete m_pProcess;         m_pProcess = 0;         Log(_("failed (to get debugger's stderr)"), Logger::error);         return -2;     }     return 0; }  /* https://svn.code.sf.net/p/codeblocks/code/tags/20.03/src/plugins/debuggergdb/gdb_driver.cpp */ wxString GDB_driver::GetCommandLine(const wxString& debugger, const wxString& debuggee, const wxString &userArguments) {     wxString cmd;     cmd << debugger;     if (m_pDBG->GetActiveConfigEx().GetFlag(DebuggerConfiguration::DisableInit))         cmd << _T(" -nx");      // don't run .gdbinit     cmd << _T(" -fullname");    // report full-path filenames when breaking     cmd << _T(" -quiet");       // don't display version on startup     cmd << wxT(" ") << userArguments;     cmd << _T(" -args ") << debuggee;     return cmd; }  wxString GDB_driver::GetCommandLine(const wxString& debugger, cb_unused int pid, const wxString &userArguments) {     wxString cmd;     cmd << debugger;     if (m_pDBG->GetActiveConfigEx().GetFlag(DebuggerConfiguration::DisableInit))         cmd << _T(" -nx");      // don't run .gdbinit     cmd << _T(" -fullname");    // report full-path filenames when breaking     cmd << _T(" -quiet");       // don't display version on startup     cmd << wxT(" ") << userArguments;     return cmd; }  /* https://svn.code.sf.net/p/codeblocks/code/tags/20.03/src/plugins/debuggergdb/cdb_driver.cpp */ wxString CDB_driver::GetCommandLine(const wxString& debugger, const wxString& debuggee, cb_unused const wxString &userArguments) {     wxString cmd = GetCommonCommandLine(debugger);     cmd << _T(' ');      // finally, add the program to debug     wxFileName debuggeeFileName(debuggee);     if (debuggeeFileName.IsAbsolute())         cmd << debuggee;     else         cmd << m_Target->GetParentProject()->GetBasePath() << wxT("/") << debuggee;      return cmd; }  wxString CDB_driver::GetCommonCommandLine(const wxString& debugger) {     wxString cmd;     cmd << debugger; //    cmd << _T(" -g"); // ignore starting breakpoint     cmd << _T(" -G"); // ignore ending breakpoint     cmd << _T(" -lines"); // line info      if (m_Target->GetTargetType() == ttConsoleOnly)         cmd << wxT(" -2"); // tell the debugger to launch a console for us      if (m_Dirs.GetCount() > 0)     {         // add symbols dirs         cmd << _T(" -y ");         for (unsigned int i = 0; i < m_Dirs.GetCount(); ++i)             cmd << m_Dirs[i] << wxPATH_SEP;          // add source dirs         cmd << _T(" -srcpath ");         for (unsigned int i = 0; i < m_Dirs.GetCount(); ++i)             cmd << m_Dirs[i] << wxPATH_SEP;     }     return cmd; }  wxString CDB_driver::GetCommandLine(const wxString& debugger, int pid, cb_unused const wxString &userArguments) {     wxString cmd = GetCommonCommandLine(debugger);     // finally, add the PID     cmd << _T(" -p ") << wxString::Format(_T("%d"), pid);     return cmd; } 

/* https://svn.code.sf.net/p/codeblocks/code/tags/20.03/src/plugins/debuggergdb/gdb_driver.cpp */  // the ">>>>>>" is a hack: sometimes, especially when watching uninitialized char* // some random control codes in the stream (like 'delete') will mess-up our prompt and the debugger // will seem like frozen (only "stop" button available). Using this dummy prefix, // we allow for a few characters to be "eaten" this way and still get our // expected prompt back. #define GDB_PROMPT _T("cb_gdb:") #define FULL_GDB_PROMPT _T(">>>>>>") GDB_PROMPT  //[Switching to thread 2 (Thread 1082132832 (LWP 12298))]#0  0x00002aaaac5a2aca in pthread_cond_wait@@GLIBC_2.3.2 () from /lib/libpthread.so.0 static wxRegEx reThreadSwitch(_T("^\\[Switching to thread .*\\]#0[ \t]+(0x[A-Fa-f0-9]+) in (.*) from (.*)")); static wxRegEx reThreadSwitch2(_T("^\\[Switching to thread .*\\]#0[ \t]+(0x[A-Fa-f0-9]+) in (.*) from (.*):([0-9]+)"));  // Regular expresion for breakpoint. wxRegEx don't want to recognize '?' command, so a bit more general rule is used // here. //  ([A-Za-z]*[:]*) corresponds to windows disk name. Under linux it can be none empty in crosscompiling sessions; //  ([^:]+) corresponds to the path in linux or to the path within windows disk in windows to current file; //  ([0-9]+) corresponds to line number in current file; //  (0x[0-9A-Fa-f]+) correponds to current memory address. static wxRegEx reBreak(_T("\032*([A-Za-z]*[:]*)([^:]+):([0-9]+):[0-9]+:[begmidl]+:(0x[0-9A-Fa-f]+)"));  static wxRegEx reBreak2(_T("^(0x[A-Fa-f0-9]+) in (.*) from (.*)")); static wxRegEx reBreak3(_T("^(0x[A-Fa-f0-9]+) in (.*)")); // Catchpoint 1 (exception thrown), 0x00007ffff7b982b0 in __cxa_throw () from /usr/lib/gcc/x86_64-pc-linux-gnu/4.4.4/libstdc++.so.6 static wxRegEx reCatchThrow(_T("^Catchpoint ([0-9]+) \\(exception thrown\\), (0x[0-9a-f]+) in (.+) from (.+)$")); // Catchpoint 1 (exception thrown), 0x00401610 in __cxa_throw () static wxRegEx reCatchThrowNoFile(_T("^Catchpoint ([0-9]+) \\(exception thrown\\), (0x[0-9a-f]+) in (.+)$"));  // easily match cygwin paths //static wxRegEx reCygwin(_T("/cygdrive/([A-Za-z])/"));  // Pending breakpoint "C:/Devel/libs/irr_svn/source/Irrlicht/CSceneManager.cpp:1077" resolved #ifdef __WXMSW__ static wxRegEx rePendingFound(_T("^Pending[ \t]+breakpoint[ \t]+[\"]+([A-Za-z]:)([^:]+):([0-9]+)\".*")); #else static wxRegEx rePendingFound(_T("^Pending[ \t]+breakpoint[ \t]+[\"]+([^:]+):([0-9]+)\".*")); #endif // Breakpoint 2, irr::scene::CSceneManager::getSceneNodeFromName (this=0x3fa878, name=0x3fbed8 "MainLevel", start=0x3fa87c) at CSceneManager.cpp:1077 static wxRegEx rePendingFound1(_T("^Breakpoint[ \t]+([0-9]+),.*"));  // Temporary breakpoint 2, main () at /path/projects/tests/main.cpp:136 static wxRegEx reTempBreakFound(wxT("^[Tt]emporary[ \t]breakpoint[ \t]([0-9]+),.*"));   // [Switching to Thread -1234655568 (LWP 18590)] // [New Thread -1234655568 (LWP 18590)] static wxRegEx reChildPid1(_T("Thread[ \t]+[xA-Fa-f0-9-]+[ \t]+\\(LWP ([0-9]+)\\)]")); // MinGW GDB 6.8 and later // [New Thread 2684.0xf40] or [New thread 2684.0xf40] static wxRegEx reChildPid2(_T("\\[New [tT]hread[ \t]+[0-9]+\\.[xA-Fa-f0-9-]+\\]"));  static wxRegEx reInferiorExited(wxT("^\\[Inferior[ \\t].+[ \\t]exited normally\\]$"), wxRE_EXTENDED); static wxRegEx reInferiorExitedWithCode(wxT("^\\[[Ii]nferior[ \\t].+[ \\t]exited[ \\t]with[ \\t]code[ \\t]([0-9]+)\\]$"), wxRE_EXTENDED);  

/* https://svn.code.sf.net/p/codeblocks/code/tags/20.03/src/plugins/debuggergdb/gdb_commands.h */  // Breakpoint 1 at 0x4013d6: file main.cpp, line 8. static wxRegEx reBreakpoint(_T("Breakpoint ([0-9]+) at (0x[0-9A-Fa-f]+)")); // GDB7.4 and before will return: // Breakpoint 1 ("/home/jens/codeblocks-build/codeblocks-1.0svn/src/plugins/debuggergdb/gdb_commands.h:125) pending. // GDB7.5 and later will return: // Breakpoint 4 ("E:/code/cb/test_code/DebugDLLTest/TestDLL/dllmain.cpp:29") pending. static wxRegEx rePendingBreakpoint(_T("Breakpoint ([0-9]+)[ \t]\\(\"(.+):([0-9]+)(\"?)\\)[ \t]pending\\.")); // Hardware assisted breakpoint 1 at 0x4013d6: file main.cpp, line 8. static wxRegEx reHWBreakpoint(_T("Hardware assisted breakpoint ([0-9]+) at (0x[0-9A-Fa-f]+)")); // Hardware watchpoint 1: expr static wxRegEx reDataBreakpoint(_T("Hardware watchpoint ([0-9]+):.*")); // Temporary breakpoint 2 at 0x401203: file /home/obfuscated/projects/tests/_cb_dbg/watches/main.cpp, line 115. static wxRegEx reTemporaryBreakpoint(wxT("^[Tt]emporary[ \t]breakpoint[ \t]([0-9]+)[ \t]at.*"));  class GdbCmd_AddBreakpoint : public DebuggerCmd {         cb::shared_ptr<DebuggerBreakpoint> m_BP;     public:         /** @param bp The breakpoint to set. */         GdbCmd_AddBreakpoint(DebuggerDriver* driver, cb::shared_ptr<DebuggerBreakpoint> bp)             : DebuggerCmd(driver),             m_BP(bp)         {             // gdb doesn't allow setting the bp number.             // instead, we must read it back in ParseOutput()...             m_BP->index = -1;              if (m_BP->enabled)             {                 if (m_BP->type == DebuggerBreakpoint::bptCode)//m_BP->func.IsEmpty())                 {                     wxString out = m_BP->filename;                     // we add one to line,  because scintilla uses 0-based line numbers, while gdb uses 1-based                     if (!m_BP->temporary)                         m_Cmd << _T("break ");                     else                         m_Cmd << _T("tbreak ");                     m_Cmd << _T('"') << out << _T(":") << wxString::Format(_T("%d"), m_BP->line) << _T('"');                 }                 else if (m_BP->type == DebuggerBreakpoint::bptData)                 {                     if (m_BP->breakOnRead && m_BP->breakOnWrite)                         m_Cmd << _T("awatch ");                     else if (m_BP->breakOnRead)                         m_Cmd << _T("rwatch ");                     else                         m_Cmd << _T("watch ");                     m_Cmd << m_BP->breakAddress;                 }                 //GDB workaround                 //Use function name if this is C++ constructor/destructor                 else                 { //                    if (m_BP->temporary) //                        cbThrow(_T("Temporary breakpoint on constructor/destructor is not allowed"));                     m_Cmd << _T("rbreak ") << m_BP->func;                 }                 //end GDB workaround                  m_BP->alreadySet = true;                 // condition and ignore count will be set in ParseOutput, where we 'll have the bp number             }         }         void ParseOutput(const wxString& output)         {             // possible outputs (we 're only interested in 1st and 2nd samples):             //             // Hardware watchpoint 1: expr             // Breakpoint 1 at 0x4013d6: file main.cpp, line 8.             // No line 100 in file "main.cpp".             // No source file named main2.cpp.             if (reBreakpoint.Matches(output))             { //                m_pDriver->DebugLog(wxString::Format(_("Breakpoint added: file %s, line %d"), m_BP->filename.c_str(), m_BP->line + 1));                 if (!m_BP->func.IsEmpty())                     m_pDriver->Log(_("GDB workaround for constructor/destructor breakpoints activated."));                  reBreakpoint.GetMatch(output, 1).ToLong(&m_BP->index);                 reBreakpoint.GetMatch(output, 2).ToULong(&m_BP->address, 16);                  // conditional breakpoint                 if (m_BP->useCondition && !m_BP->condition.IsEmpty())                 {                     m_pDriver->QueueCommand(new GdbCmd_AddBreakpointCondition(m_pDriver, m_BP), DebuggerDriver::High);                 }                  // ignore count                 if (m_BP->useIgnoreCount && m_BP->ignoreCount > 0)                 {                     wxString cmd;                     cmd << _T("ignore ") << wxString::Format(_T("%d"), (int) m_BP->index) << _T(" ") << wxString::Format(_T("%d"), (int) m_BP->ignoreCount);                     m_pDriver->QueueCommand(new DebuggerCmd(m_pDriver, cmd), DebuggerDriver::High);                 }             }             else if (rePendingBreakpoint.Matches(output))             {                 if (!m_BP->func.IsEmpty())                     m_pDriver->Log(_("GDB workaround for constructor/destructor breakpoints activated."));                  rePendingBreakpoint.GetMatch(output, 1).ToLong(&m_BP->index);                  // conditional breakpoint                 // condition can not be evaluated for pending breakpoints, so we only set a flag and do this later                 if (m_BP->useCondition && !m_BP->condition.IsEmpty())                 {                     m_BP->wantsCondition = true;                 }                  // ignore count                 if (m_BP->useIgnoreCount && m_BP->ignoreCount > 0)                 {                     wxString cmd;                     cmd << _T("ignore ") << wxString::Format(_T("%d"), (int) m_BP->index) << _T(" ") << wxString::Format(_T("%d"), (int) m_BP->ignoreCount);                     m_pDriver->QueueCommand(new DebuggerCmd(m_pDriver, cmd), DebuggerDriver::High);                 }             }             else if (reDataBreakpoint.Matches(output))             {                 reDataBreakpoint.GetMatch(output, 1).ToLong(&m_BP->index);             }             else if (reHWBreakpoint.Matches(output))             {                 reHWBreakpoint.GetMatch(output, 1).ToLong(&m_BP->index);                 reHWBreakpoint.GetMatch(output, 2).ToULong(&m_BP->address, 16);             }             else if (reTemporaryBreakpoint.Matches(output))                 reTemporaryBreakpoint.GetMatch(output, 1).ToLong(&m_BP->index);             else                 m_pDriver->Log(output); // one of the error responses              Manager::Get()->GetDebuggerManager()->GetBreakpointDialog()->Reload();         } }; 

/* https://svn.code.sf.net/p/codeblocks/code/tags/20.03/src/plugins/debuggergdb/cdb_commands.h */ class CdbCmd_AddBreakpoint : public DebuggerCmd {         static int m_lastIndex;     public:         /** @param bp The breakpoint to set. */         CdbCmd_AddBreakpoint(DebuggerDriver* driver, cb::shared_ptr<DebuggerBreakpoint> bp)             : DebuggerCmd(driver),             m_BP(bp)         {             if (bp->enabled)             {                 if (bp->index==-1)                     bp->index = m_lastIndex++;                  wxString out = m_BP->filename; //                DebuggerGDB::ConvertToGDBFile(out);                 QuoteStringIfNeeded(out);                 // we add one to line,  because scintilla uses 0-based line numbers, while cdb uses 1-based                 m_Cmd << _T("bu") << wxString::Format(_T("%ld"), (int) bp->index) << _T(' ');                 if (m_BP->temporary)                     m_Cmd << _T("/1 ");                 if (bp->func.IsEmpty())                     m_Cmd << _T('`') << out << _T(":") << wxString::Format(_T("%d"), bp->line) << _T('`');                 else                     m_Cmd << bp->func;                 bp->alreadySet = true;             }         }         void ParseOutput(const wxString& output)         {             // possible outputs (only output lines starting with ***):             //             // *** WARNING: Unable to verify checksum for Win32GUI.exe             // *** ERROR: Symbol file could not be found.  Defaulted to export symbols for C:\WINDOWS\system32\USER32.dll -             // *** ERROR: Symbol file could not be found.  Defaulted to export symbols for C:\WINDOWS\system32\GDI32.dll -             wxArrayString lines = GetArrayFromString(output, _T('\n'));             for (unsigned int i = 0; i < lines.GetCount(); ++i)             {                 if (lines[i].StartsWith(_T("*** ")))                     m_pDriver->Log(lines[i]);             }         }          cb::shared_ptr<DebuggerBreakpoint> m_BP; }; 

public abstract class JavaBreakpoint {     /* https://github.com/eclipse-jdt/eclipse.jdt.debug/blob/5b7b412f5388ec404a675a77b186a744bf0063bf/org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/breakpoints/JavaBreakpoint.java#L512 */     protected boolean createRequest(JDIDebugTarget target, ReferenceType type)         throws CoreException {         if (shouldSkipBreakpoint()) {             return false;         }         EventRequest[] requests = newRequests(target, type);         if (requests == null) {             return false;         }         fInstalledTypeName = type.name();         for (EventRequest request : requests) {             registerRequest(request, target);         }         return true;     }      /* https://github.com/eclipse-jdt/eclipse.jdt.debug/blob/5b7b412f5388ec404a675a77b186a744bf0063bf/org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/breakpoints/JavaBreakpoint.java#L537 */     protected void configureRequest(EventRequest request, JDIDebugTarget target)             throws CoreException {         request.setSuspendPolicy(getJDISuspendPolicy());         request.putProperty(JAVA_BREAKPOINT_PROPERTY, this);         configureRequestThreadFilter(request, target);         configureRequestHitCount(request);         configureInstanceFilters(request, target);         // Important: only enable a request after it has been configured         updateEnabledState(request, target);     }      /*  https://github.com/eclipse-jdt/eclipse.jdt.debug/blob/5b7b412f5388ec404a675a77b186a744bf0063bf/org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/breakpoints/JavaBreakpoint.java#L226*/ protected void registerRequest(EventRequest request, JDIDebugTarget target) throws CoreException { if (request == null) { return; } List<EventRequest> reqs = getRequests(target); if (reqs.isEmpty()) { fRequestsByTarget.put(target, reqs); } reqs.add(request); target.addJDIEventListener(this, request); // update the install attribute on the breakpoint if (!(request instanceof ClassPrepareRequest)) { incrementInstallCount(); // notification fireInstalled(target); } } }  public class JavaLineBreakpoint extends JavaBreakpoint {     /* https://github.com/eclipse-jdt/eclipse.jdt.debug/blob/5b7b412f5388ec404a675a77b186a744bf0063bf/org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/breakpoints/JavaLineBreakpoint.java#L289 */     @Override protected EventRequest[] newRequests(JDIDebugTarget target, ReferenceType type) throws CoreException { int lineNumber = getLineNumber(); List<Location> locations = determineLocations(lineNumber, type, target); locations = filterLocations(locations); EventRequest[] requests = new EventRequest[locations.size()]; int i = 0; for(Location location : locations) { requests[i] = createLineBreakpointRequest(location, target); i++; } return requests; }      /* https://github.com/eclipse-jdt/eclipse.jdt.debug/blob/5b7b412f5388ec404a675a77b186a744bf0063bf/org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/breakpoints/JavaLineBreakpoint.java#L345 */ protected BreakpointRequest createLineBreakpointRequest(Location location, JDIDebugTarget target) throws CoreException { EventRequestManager manager = target.getEventRequestManager();         /* ... */         BreakpointRequest request = manager.createBreakpointRequest(location);         /* ... */         configureRequest(request, target);         /* ... */         return request; } }  

public abstract class EventRequestImpl extends MirrorImpl implements EventRequest {     /* https://github.com/eclipse-jdt/eclipse.jdt.debug/blob/5b7b412f5388ec404a675a77b186a744bf0063bf/org.eclipse.jdt.debug/jdi/org/eclipse/jdi/internal/request/EventRequestImpl.java#L262 */ @Override public synchronized void enable() { initJdwpRequest();         ByteArrayOutputStream outBytes = new ByteArrayOutputStream();         DataOutputStream outData = new DataOutputStream(outBytes);         writeByte(eventKind(),                 "event kind", EventImpl.eventKindMap(), outData); //$NON-NLS-1$         writeByte(                 suspendPolicyJDWP(),                 "suspend policy", EventRequestImpl.suspendPolicyMap(), outData); //$NON-NLS-1$         writeInt(modifierCount(), "modifiers", outData); //$NON-NLS-1$         writeModifiers(outData);          JdwpReplyPacket replyPacket = requestVM(JdwpCommandPacket.ER_SET, outBytes);         defaultReplyErrorHandler(replyPacket.errorCode());         DataInputStream replyData = replyPacket.dataInStream();         fRequestID = RequestID.read(this, replyData);         virtualMachineImpl().eventRequestManagerImpl().addRequestIDMapping(this); } } 

/* org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/model/JDIDebugTarget.java */ public class JDIDebugTarget {     /* https://github.com/eclipse-jdt/eclipse.jdt.debug/blob/5b7b412f5388ec404a675a77b186a744bf0063bf/org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/model/JDIDebugTarget.java#L380 */     public JDIDebugTarget(ILaunch launch, VirtualMachine jvm, String name, boolean supportTerminate, boolean supportDisconnect, IProcess process, boolean resume) { /* ... */ initialize();         /* ... */ }      /* https://github.com/eclipse-jdt/eclipse.jdt.debug/blob/5b7b412f5388ec404a675a77b186a744bf0063bf/org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/model/JDIDebugTarget.java#L524 */ protected synchronized void initialize() { setEventDispatcher(new EventDispatcher(this)); /* ... */ plugin.asyncExec(() -> { EventDispatcher dispatcher = getEventDispatcher(); if (dispatcher != null) { Thread t = new Thread( dispatcher, JDIDebugModel.getPluginIdentifier() + JDIDebugModelMessages.JDIDebugTarget_JDI_Event_Dispatcher); t.setDaemon(true); t.start(); } }); } }  /* org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/EventDispatcher.java */ public class EventDispatcher implements Runnable {     /* https://github.com/eclipse-jdt/eclipse.jdt.debug/blob/5b7b412f5388ec404a675a77b186a744bf0063bf/org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/EventDispatcher.java#L304 */ @Override public void run() {         VirtualMachine vm = fTarget.getVM();         EventQueue q = vm.eventQueue();         while (!isShutdown()) {             EventSet eventSet;             try {                 // Get the next event set.                 eventSet = q.remove(1000);             } catch (VMDisconnectedException e) {                 break;             }              dispatch(eventSet);         } }      /* https://github.com/eclipse-jdt/eclipse.jdt.debug/blob/5b7b412f5388ec404a675a77b186a744bf0063bf/org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/EventDispatcher.java#L105 */ private void dispatch(EventSet eventSet) { EventIterator iter = eventSet.eventIterator(); IJDIEventListener[] listeners = new IJDIEventListener[eventSet.size()]; boolean vote = false; boolean resume = true; int index = -1; List<Event> deferredEvents = null; while (iter.hasNext()) { index++; Event event = iter.nextEvent(); // Dispatch events to registered listeners, if any IJDIEventListener listener = fEventHandlers.get(event.request()); listeners[index] = listener; if (listener != null) { if (listener instanceof IJavaLineBreakpoint) { // Event dispatch to conditional breakpoints is deferred // until after // other listeners vote. try { if (((IJavaLineBreakpoint) listener).isConditionEnabled()) { if (deferredEvents == null) { deferredEvents = new ArrayList<>(5); } deferredEvents.add(event); continue; } } catch (CoreException exception) { JDIDebugPlugin.log(exception); } } vote = true; try { try { resume = listener.handleEvent(event, fTarget, !resume, eventSet) && resume; } finally { enableGCForExceptionEvent(event); } } catch (Throwable t) { logHandleEventError(listener, event, t); } continue; }  // Dispatch VM start/end events if (event instanceof VMDeathEvent) { fTarget.handleVMDeath((VMDeathEvent) event); shutdown(); // stop listening for events } else if (event instanceof VMDisconnectEvent) { fTarget.handleVMDisconnect((VMDisconnectEvent) event); shutdown(); // stop listening for events } else if (event instanceof VMStartEvent) { fTarget.handleVMStart((VMStartEvent) event); } else { // not handled } }         /* ... */ } } 

class DebuggerWidget:     # https://github.com/spyder-ide/spyder/blob/49e81efdf9090d816cd11d7afc7cf2959273eeae/spyder/plugins/debugger/widgets/main_widget.py#L210     def setup(self):         # ...         next_action = self.create_action(             DebuggerWidgetActions.Next,             text=_("Execute current line"),             icon=self.create_icon('arrow-step-over'),             triggered=lambda: self.debug_command("next"),             register_shortcut=True         )          continue_action = self.create_action(             DebuggerWidgetActions.Continue,             text=_("Continue execution until next breakpoint"),             icon=self.create_icon('arrow-continue'),             triggered=lambda: self.debug_command("continue"),             register_shortcut=True         )          step_action = self.create_action(             DebuggerWidgetActions.Step,             text=_("Step into function or method"),             icon=self.create_icon('arrow-step-in'),             triggered=lambda: self.debug_command("step"),             register_shortcut=True         )          return_action = self.create_action(             DebuggerWidgetActions.Return,             text=_("Execute until function or method returns"),             icon=self.create_icon('arrow-step-out'),             triggered=lambda: self.debug_command("return"),             register_shortcut=True         )         # ...      # https://github.com/spyder-ide/spyder/blob/49e81efdf9090d816cd11d7afc7cf2959273eeae/spyder/plugins/debugger/widgets/main_widget.py#L672     def debug_command(self, command):         """Debug actions"""         self.sig_unmaximize_plugin_requested.emit()         widget = self.current_widget()         if widget is None:             return         widget.shellwidget.pdb_execute_command(command)  class DebuggingWidget:     # https://github.com/spyder-ide/spyder/blob/49e81efdf9090d816cd11d7afc7cf2959273eeae/spyder/plugins/ipythonconsole/widgets/debugging.py#L282     def pdb_execute_command(self, command):         """         Execute a pdb command         """         self._pdb_take_focus = False         self.pdb_execute(             self._pdb_cmd_prefix() + command, hidden=False,             echo_stack_entry=False, add_history=False)      # https://github.com/spyder-ide/spyder/blob/49e81efdf9090d816cd11d7afc7cf2959273eeae/spyder/plugins/ipythonconsole/widgets/debugging.py#L317     def pdb_execute(self, line, hidden=False, echo_stack_entry=True,                     add_history=True):         # ...         self.executing.emit(line)         # ... 

@magics_class class SpyderCodeRunner(Magics):     # https://github.com/spyder-ide/spyder/blob/49e81efdf9090d816cd11d7afc7cf2959273eeae/external-deps/spyder-kernels/spyder_kernels/customize/code_runner.py#L179     @runfile_arguments     @needs_local_scope     @line_magic     def debugfile(self, line, local_ns=None):         """         Debug a file.         """         args, local_ns = self._parse_runfile_argstring(             self.debugfile, line, local_ns)          with self._debugger_exec(args.canonic_filename, True) as debug_exec:             self._exec_file(                 filename=args.filename,                 canonic_filename=args.canonic_filename,                 args=args.args,                 wdir=args.wdir,                 exec_fun=debug_exec             )      # https://github.com/spyder-ide/spyder/blob/49e81efdf9090d816cd11d7afc7cf2959273eeae/external-deps/spyder-kernels/spyder_kernels/customize/code_runner.py#L238     @contextmanager     def _debugger_exec(self, filename, continue_if_has_breakpoints):         """Get an exec function to use for debugging."""         if not self.shell.is_debugging():             debugger = SpyderPdb()             debugger.set_remote_filename(filename)             debugger.continue_if_has_breakpoints = continue_if_has_breakpoints             yield debugger.run             return      # https://github.com/spyder-ide/spyder/blob/49e81efdf9090d816cd11d7afc7cf2959273eeae/external-deps/spyder-kernels/spyder_kernels/customize/code_runner.py#L258     def _exec_file(         self,         filename=None,         args=None,         wdir=None,         current_namespace=False,         exec_fun=None     ):         # ...         self._exec_code(             file_code,             filename,             ns_globals,             ns_locals,             exec_fun=exec_fun)         # ...      # https://github.com/spyder-ide/spyder/blob/49e81efdf9090d816cd11d7afc7cf2959273eeae/external-deps/spyder-kernels/spyder_kernels/customize/code_runner.py#L438     def _exec_code(         self,         code,         filename,         ns_globals,         ns_locals=None,         exec_fun=None     ):         # ...         ast_code = ast.parse(self._transform_cell(code))         # ...         exec_encapsulate_locals(             ast_code, ns_globals, ns_locals, exec_fun, filename         )         # ...  # https://github.com/spyder-ide/spyder/blob/49e81efdf9090d816cd11d7afc7cf2959273eeae/external-deps/spyder-kernels/spyder_kernels/customize/utils.py#L132 def exec_encapsulate_locals(     code_ast, globals, locals, exec_fun=None, filename=None ):     # exec_fun == SpyderPdb.run     exec_fun(compile(code_ast, filename, "exec"), globals, None)  # https://github.com/spyder-ide/spyder/blob/49e81efdf9090d816cd11d7afc7cf2959273eeae/external-deps/spyder-kernels/spyder_kernels/customize/spyderpdb.py#L850 class SpyderPdb(ipyPdb):     def run(self, cmd, globals=None, locals=None):         """Debug a statement executed via the exec() function.          globals defaults to __main__.dict; locals defaults to globals.         """         with DebugWrapper(self):             # Вызывает Bdb.run()             super(SpyderPdb, self).run(cmd, globals, locals) 

Я немного обманул: cmdloop — метод не самого Pdb, а его базового класса Cmd, но смысл прежний — обрабатываем пользовательский ввод в цикле.

class Cmd:     # https://github.com/python/cpython/blob/be8ae086874cac42eea104c1ff21ef5868d50bdd/Lib/cmd.py#L98     def cmdloop(self, intro=None):         stop = None         while not stop:             # ...             line = self.stdin.readline()             # ...             stop = self.onecmd(line)             # ...      # https://github.com/python/cpython/blob/be8ae086874cac42eea104c1ff21ef5868d50bdd/Lib/cmd.py#L200     def onecmd(self, line):         cmd, arg, line = self.parseline(line)         if not line:             return self.emptyline()         if cmd is None:             return self.default(line)         self.lastcmd = line         if line == 'EOF' :             self.lastcmd = ''         if cmd == '':             return self.default(line)         else:             try:                 func = getattr(self, 'do_' + cmd)             except AttributeError:                 return self.default(line)             return func(arg)  class SpyderPdb(ipyPdb):     # https://github.com/spyder-ide/spyder/blob/49e81efdf9090d816cd11d7afc7cf2959273eeae/external-deps/spyder-kernels/spyder_kernels/customize/spyderpdb.py#L134     def default(self, line):         if line[:1] == '!':             line = line[1:]         # ...         cmd, arg, line = self.parseline(line)         # ...         cmd_func = getattr(self, 'do_' + cmd, None)         # ...         return cmd_func(arg)         # ...  class Pdb(bdb.Bdb, cmd.Cmd):     # https://github.com/python/cpython/blob/be8ae086874cac42eea104c1ff21ef5868d50bdd/Lib/pdb.py#L1596     def do_next(self, arg):         self.set_next(self.curframe)         return 1      # https://github.com/python/cpython/blob/be8ae086874cac42eea104c1ff21ef5868d50bdd/Lib/pdb.py#L1582     def do_step(self, arg):         self.set_step()         return 1      # https://github.com/python/cpython/blob/be8ae086874cac42eea104c1ff21ef5868d50bdd/Lib/pdb.py#L1557     def do_until(self, arg):         if arg:             try:                 lineno = int(arg)             except ValueError:                 self.error('Error in argument: %r' % arg)                 return             if lineno <= self.curframe.f_lineno:                 self.error('"until" line number is smaller than current '                            'line number')                 return         else:             lineno = None         self.set_until(self.curframe, lineno)         return 1 

class SpyderPdb(ipyPdb):     # https://github.com/spyder-ide/spyder/blob/49e81efdf9090d816cd11d7afc7cf2959273eeae/external-deps/spyder-kernels/spyder_kernels/customize/spyderpdb.py#L772     def set_spyder_breakpoints(self, breakpoints):         """Set Spyder breakpoints."""         self.clear_all_breaks()         # -----Really deleting all breakpoints:         for bp in bdb.Breakpoint.bpbynumber:             if bp:                 bp.deleteMe()         bdb.Breakpoint.next = 1         bdb.Breakpoint.bplist = {}         bdb.Breakpoint.bpbynumber = [None]         # -----         for fname, data in list(breakpoints.items()):             for linenumber, condition in data:                 try:                     self.set_break(self.canonic(fname), linenumber,                                    cond=condition)                 except ValueError:                     # Fixes spyder/issues/15546                     # The file is not readable                     pass      breakpoints = property(fset=set_spyder_breakpoints) 

int main(int argc, const char **argv) {     DEBUG_EVENT event;      STARTUPINFO si;     PROCESS_INFORMATION pi;      ZeroMemory(&si, sizeof(si));     ZeroMemory(&pi, sizeof(pi));      si.cb = sizeof(si);     GetStartupInfo(&si);     CreateProcess(NULL,                    L"dir",                                  // Запускаем 'dir' в качестве примера                   NULL, NULL, FALSE,                    DEBUG_PROCESS | DEBUG_ONLY_THIS_PROCESS, // Отлаживаем только этот процесс                   NULL, NULL,                   &si, &pi);      child_pid = pi.dwProcessId;     child_tid = pi.dwThreadId;     child_pHandle = pi.hProcess;     child_tHandle = pi.hThread;      while (TRUE) {         BOOL should_stop = FALSE;         DWORD continue_flag = DBG_EXCEPTION_NOT_HANDLED;                  if (!WaitForDebugEvent(&event, INFINITE)) {             break;         }          switch (event.dwDebugEventCode) {             case EXCEPTION_DEBUG_EVENT:                 // В процессе случилось исключение.                 // Вызывается также и тогда, когда достигнута инструкция остановки (int3)                 EXCEPTION_DEBUG_INFO *edi = &event.u.Exception;                 break;             case CREATE_PROCESS_DEBUG_EVENT:                 // Создан новый процесс                 CREATE_PROCESS_DEBUG_INFO *cpdi = &event.u.CreateProcessInfo;                 break;             case EXIT_PROCESS_DEBUG_EVENT:                 // Процесс завершается                 should_stop = TRUE;                 EXIT_PROCESS_DEBUG_INFO *epdi = &event.u.ExitProcess;                 break;             case OUTPUT_DEBUG_STRING_EVENT:                 // Отлаживаемый процесс вызывает DebugOutputString - посылает строку отладчику                 OUTPUT_DEBUG_STRING_INFO *odsi = &event.u.DebugString;                 break;             case CREATE_THREAD_DEBUG_EVENT:                 // Создан новый поток                 CREATE_THREAD_DEBUG_INFO *ctdi = &event.u.CreateThread;                 break;             case EXIT_THREAD_DEBUG_EVENT:                 // Поток завершается                 EXIT_THREAD_DEBUG_INFO *etdi = &event.u.ExitThread;                 break;             case LOAD_DLL_DEBUG_EVENT:                 // Загружается DLL                 LOAD_DLL_DEBUG_INFO *lddi = &event.u.LoadDll;                 break;             case UNLOAD_DLL_DEBUG_EVENT:                 // DDL выгружается                 UNLOAD_DLL_DEBUG_INFO *uddi = &event.u.UnloadDll;                 break;             case RIP_EVENT:                 // Системная ошибка                 RIP_INFO *ri = &event.u.RipInfo;                 should_stop = TRUE;                 break;         }          if (should_stop) {             break;         }                  // Продолжаем выполнение         ContinueDebugEvent(event.dwProcessId, event.dwThreadId, continue_flag);     }      CloseHandle(child_pHandle);     CloseHandle(child_tHandle);     return 0; } 

Когда писал код выше, то в lldb не смотрел. На удивление, этот кусок сильно похож на мой.

// https://github.com/llvm/llvm-project/blob/ab51eccf88f5321e7c60591c5546b254b6afab99/lldb/source/Plugins/Process/Windows/Common/DebuggerThread.cpp#L232 void DebuggerThread::DebugLoop() {   DEBUG_EVENT dbe = {};   bool should_debug = true;   while (should_debug) {     BOOL wait_result = WaitForDebugEvent(&dbe, INFINITE);     if (wait_result) {       DWORD continue_status = DBG_CONTINUE;       bool shutting_down = m_is_shutting_down;       switch (dbe.dwDebugEventCode) {       default:         llvm_unreachable("Unhandle debug event code!");       case EXCEPTION_DEBUG_EVENT: {         ExceptionResult status = HandleExceptionEvent(             dbe.u.Exception, dbe.dwThreadId, shutting_down);          if (status == ExceptionResult::MaskException)           continue_status = DBG_CONTINUE;         else if (status == ExceptionResult::SendToApplication)           continue_status = DBG_EXCEPTION_NOT_HANDLED;          break;       }       case CREATE_THREAD_DEBUG_EVENT:         continue_status =             HandleCreateThreadEvent(dbe.u.CreateThread, dbe.dwThreadId);         break;       case CREATE_PROCESS_DEBUG_EVENT:         continue_status =             HandleCreateProcessEvent(dbe.u.CreateProcessInfo, dbe.dwThreadId);         break;       case EXIT_THREAD_DEBUG_EVENT:         continue_status =             HandleExitThreadEvent(dbe.u.ExitThread, dbe.dwThreadId);         break;       case EXIT_PROCESS_DEBUG_EVENT:         continue_status =             HandleExitProcessEvent(dbe.u.ExitProcess, dbe.dwThreadId);         should_debug = false;         break;       case LOAD_DLL_DEBUG_EVENT:         continue_status = HandleLoadDllEvent(dbe.u.LoadDll, dbe.dwThreadId);         break;       case UNLOAD_DLL_DEBUG_EVENT:         continue_status = HandleUnloadDllEvent(dbe.u.UnloadDll, dbe.dwThreadId);         break;       case OUTPUT_DEBUG_STRING_EVENT:         continue_status = HandleODSEvent(dbe.u.DebugString, dbe.dwThreadId);         break;       case RIP_EVENT:         continue_status = HandleRipEvent(dbe.u.RipInfo, dbe.dwThreadId);         if (dbe.u.RipInfo.dwType == SLE_ERROR)           should_debug = false;         break;       }        ::ContinueDebugEvent(dbe.dwProcessId, dbe.dwThreadId, continue_status);        // We have to DebugActiveProcessStop after ContinueDebugEvent, otherwise       // the target process will crash       if (shutting_down) {         // A breakpoint that occurs while `m_pid_to_detach` is non-zero is a         // magic exception that we use simply to wake up the DebuggerThread so         // that we can close out the debug loop.         if (m_pid_to_detach != 0 &&             (dbe.u.Exception.ExceptionRecord.ExceptionCode ==                  EXCEPTION_BREAKPOINT ||              dbe.u.Exception.ExceptionRecord.ExceptionCode ==                  STATUS_WX86_BREAKPOINT)) {            // detaching with leaving breakpoint exception event on the queue may           // cause target process to crash so process events as possible since           // target threads are running at this time, there is possibility to           // have some breakpoint exception between last WaitForDebugEvent and           // DebugActiveProcessStop but ignore for now.           while (WaitForDebugEvent(&dbe, 0)) {             continue_status = DBG_CONTINUE;             if (dbe.dwDebugEventCode == EXCEPTION_DEBUG_EVENT &&                 !(dbe.u.Exception.ExceptionRecord.ExceptionCode ==                       EXCEPTION_BREAKPOINT ||                   dbe.u.Exception.ExceptionRecord.ExceptionCode ==                       STATUS_WX86_BREAKPOINT ||                   dbe.u.Exception.ExceptionRecord.ExceptionCode ==                       EXCEPTION_SINGLE_STEP))               continue_status = DBG_EXCEPTION_NOT_HANDLED;             ::ContinueDebugEvent(dbe.dwProcessId, dbe.dwThreadId,                                  continue_status);           }            ::DebugActiveProcessStop(m_pid_to_detach);           m_detached = true;         }       }        if (m_detached) {         should_debug = false;       }     } else {       should_debug = false;     }   }   FreeProcessHandles();    ::SetEvent(m_debugging_ended_event); } 

Эти исключения не относятся конкретно к отладчику, а к механизму SEH (Structured Exception Handling) в Windows. В __try/__except блоке можно вызвать функцию GetExceptionCode и получить код возникшей ошибки.

Он позволяет обрабатывать различные исключения — как hardware, так и software. Для их обработки он определяет 3* ключевых слова:

• __try — try

• __except — catch/except

• __finally — finally

Тут стоит рассказать о концепции first-chance exception. Если коротко, то при возникновении исключения отладчику могут дать возможность первому попытаться обработать исключение (дают ему первый шанс). Но как понять, что исключение обработано? Тут в игру вступают флаги, передаваемые ContinueDebugEvent: DBG_CONTINUE — исключение обработано, DBG_EXCEPTION_NOT_HANDLED — НЕ обработано. В первом случае, этого исключения как будто и не было, а во втором запустится стандартный поток обработки исключения в самом процессе.

Последний шаг: EXCEPTION_BREAKPOINT И EXCEPTION_SINGLE_STEP — это first-chance исключения. Мы в принципе сами может их обработать (пример из официальной документации Microsoft):

/* https://learn.microsoft.com/ru-ru/windows/win32/debug/using-an-exception-handler#example-2 */ BOOL CheckForDebugger() {     __try      {         DebugBreak();     }     __except(GetExceptionCode() == EXCEPTION_BREAKPOINT ?               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)      {         // No debugger is attached, so return FALSE          // and continue.         return FALSE;     }     return TRUE; } 

Я сказал 3 ключевых слова под звездочкой, так как согласно той же документации функцию GetExceptionCode компилятор Microsoft обрабатывает его как ключевое слово и выдает ошибку, если использовать вне __try/__except блоков.

static BYTE set_breakpoint(LPVOID pAddress) {     BYTE saved;     SIZE_T numberOfBytes;     ReadProcessMemory(child_pHandle, pAddress, (LPVOID)&saved, sizeof(saved), &numberOfBytes);      BYTE br = 0xCC;     WriteProcessMemory(child_pHandle, pAddress, &br, sizeof(BYTE), &numberOfBytes);     FlushInstructionCache(child_pHandle, pAddress, sizeof(BYTE));          return saved; } 

/* https://github.com/llvm/llvm-project/blob/ab51eccf88f5321e7c60591c5546b254b6afab99/lldb/source/Host/common/NativeProcessProtocol.cpp#L422 */ llvm::Expected<NativeProcessProtocol::SoftwareBreakpoint> NativeProcessProtocol::EnableSoftwareBreakpoint(lldb::addr_t addr,                                                 uint32_t size_hint) {   auto expected_trap = GetSoftwareBreakpointTrapOpcode(size_hint);   if (!expected_trap)     return expected_trap.takeError();    llvm::SmallVector<uint8_t, 4> saved_opcode_bytes(expected_trap->size(), 0);   // Save the original opcodes by reading them so we can restore later.   size_t bytes_read = 0;   Status error = ReadMemory(addr, saved_opcode_bytes.data(),                             saved_opcode_bytes.size(), bytes_read);   if (error.Fail())     return error.ToError();    // Ensure we read as many bytes as we expected.   if (bytes_read != saved_opcode_bytes.size()) {     return llvm::createStringError(         llvm::inconvertibleErrorCode(),         "Failed to read memory while attempting to set breakpoint: attempted "         "to read {0} bytes but only read {1}.",         saved_opcode_bytes.size(), bytes_read);   }    // Write a software breakpoint in place of the original opcode.   size_t bytes_written = 0;   error = WriteMemory(addr, expected_trap->data(), expected_trap->size(),                       bytes_written);   if (error.Fail())     return error.ToError();    // Ensure we wrote as many bytes as we expected.   if (bytes_written != expected_trap->size()) {     return llvm::createStringError(         llvm::inconvertibleErrorCode(),         "Failed write memory while attempting to set "         "breakpoint: attempted to write {0} bytes but only wrote {1}",         expected_trap->size(), bytes_written);   }    llvm::SmallVector<uint8_t, 4> verify_bp_opcode_bytes(expected_trap->size(),                                                        0);   size_t verify_bytes_read = 0;   error = ReadMemory(addr, verify_bp_opcode_bytes.data(),                      verify_bp_opcode_bytes.size(), verify_bytes_read);   if (error.Fail())     return error.ToError();    // Ensure we read as many verification bytes as we expected.   if (verify_bytes_read != verify_bp_opcode_bytes.size()) {     return llvm::createStringError(         llvm::inconvertibleErrorCode(),         "Failed to read memory while "         "attempting to verify breakpoint: attempted to read {0} bytes "         "but only read {1}",         verify_bp_opcode_bytes.size(), verify_bytes_read);   }    if (llvm::ArrayRef(verify_bp_opcode_bytes.data(), verify_bytes_read) !=       *expected_trap) {     return llvm::createStringError(         llvm::inconvertibleErrorCode(),         "Verification of software breakpoint "         "writing failed - trap opcodes not successfully read back "         "after writing when setting breakpoint at {0:x}",         addr);   }    return SoftwareBreakpoint{1, saved_opcode_bytes, *expected_trap}; } 

/* https://github.com/llvm/llvm-project/blob/ab51eccf88f5321e7c60591c5546b254b6afab99/lldb/source/Plugins/Process/Windows/Common/ProcessDebugger.cpp#L262 */ Status ProcessDebugger::ReadMemory(lldb::addr_t vm_addr, void *buf, size_t size,                                    size_t &bytes_read) {   Status error;   bytes_read = 0;   lldb::process_t handle = m_session_data->m_debugger->GetProcess()                                .GetNativeProcess()                                .GetSystemHandle();   void *addr = reinterpret_cast<void *>(vm_addr);   SIZE_T num_of_bytes_read = 0;   if (::ReadProcessMemory(handle, addr, buf, size, &num_of_bytes_read)) {     bytes_read = num_of_bytes_read;     return Status();   }   error = Status(GetLastError(), eErrorTypeWin32);   MemoryRegionInfo info;   if (GetMemoryRegionInfo(vm_addr, info).Fail() ||       info.GetMapped() != MemoryRegionInfo::OptionalBool::eYes)     return error;   size = info.GetRange().GetRangeEnd() - vm_addr;   if (::ReadProcessMemory(handle, addr, buf, size, &num_of_bytes_read)) {     bytes_read = num_of_bytes_read;     return Status();   }   error = Status(GetLastError(), eErrorTypeWin32);   return error; } 

/* https://github.com/llvm/llvm-project/blob/ab51eccf88f5321e7c60591c5546b254b6afab99/lldb/source/Plugins/Process/Windows/Common/ProcessDebugger.cpp#L292 */ Status ProcessDebugger::WriteMemory(lldb::addr_t vm_addr, const void *buf,                                     size_t size, size_t &bytes_written) {   /* ... */   HostProcess process = m_session_data->m_debugger->GetProcess();   void *addr = reinterpret_cast<void *>(vm_addr);   SIZE_T num_of_bytes_written = 0;   lldb::process_t handle = process.GetNativeProcess().GetSystemHandle();   if (::WriteProcessMemory(handle, addr, buf, size, &num_of_bytes_written)) {     FlushInstructionCache(handle, addr, num_of_bytes_written);     bytes_written = num_of_bytes_written;   } else {     error = Status(GetLastError(), eErrorTypeWin32);   }   return error; } 

Вы уже могли заметить сочетание SoftwareBreakpoint. Можно выделить 2 типа точек останова: software и hardware. Если говорить грубо, то:

• software — это инструкции точки останова

• hardware — это CPU исключения

До этого момента мы использовали только software точки останова — ставили инструкцию 0xCC. Они доступны практически для любого CPU так как не требуют особых условий.

hardware с другой стороны, как можно догадаться, используют возможности CPU. С одной стороны, эти точки останова сильно зависят от железа (CPU) и их количество сильно ограничено. С другой, они позволяют то, чего software нет, в частности, точка останова при изменении данных по определенному адресу.

О hardware/software мы поговорим позже.

static void make_single_step() {     /* Выставление режима Single step */     CONTEXT ctx;     GetThreadContext(child_hThread, &ctx);     ctx.EFlags |= 0x100;     SetThreadContext(child_hThread, &ctx);      /* Продолжение работы */     ContinueDebugEvent(child_hProcess, child_hThread, DBG_CONTINUE);     DEBUG_EVENT event;     WaitForDebugEvent(&event, INFINITE);     if (event.dwDebugEventCode == EXCEPTION_DEBUG_EVENT &&          event.u.Exception.ExceptionRecord.ExceptionCode == EXCEPTION_SINGLE_STEP) {         /* Single step */     } } 

Поле называется EFLAGS. Это название из 32-битного мира, для 64-битных используется префикс R.

/* https://github.com/llvm/llvm-project/blob/ab51eccf88f5321e7c60591c5546b254b6afab99/lldb/source/Plugins/Process/Windows/Common/TargetThreadWindows.cpp#L126 */ Status TargetThreadWindows::DoResume() {   StateType resume_state = GetTemporaryResumeState();   StateType current_state = GetState();   if (resume_state == current_state)     return Status();    if (resume_state == eStateStepping) {     Log *log = GetLog(LLDBLog::Thread);      uint32_t flags_index =         GetRegisterContext()->ConvertRegisterKindToRegisterNumber(             eRegisterKindGeneric, LLDB_REGNUM_GENERIC_FLAGS);     uint64_t flags_value =         GetRegisterContext()->ReadRegisterAsUnsigned(flags_index, 0);     ProcessSP process = GetProcess();     const ArchSpec &arch = process->GetTarget().GetArchitecture();     switch (arch.GetMachine()) {     /*       *       * Выставляем флаг TF      *      */     case llvm::Triple::x86:     case llvm::Triple::x86_64:       flags_value |= 0x100; // Set the trap flag on the CPU       break;     case llvm::Triple::aarch64:     case llvm::Triple::arm:     case llvm::Triple::thumb:       flags_value |= 0x200000; // The SS bit in PState       break;     default:       LLDB_LOG(log, "single stepping unsupported on this architecture");       break;     }     GetRegisterContext()->WriteRegisterFromUnsigned(flags_index, flags_value);   }    if (resume_state == eStateStepping || resume_state == eStateRunning) {     DWORD previous_suspend_count = 0;     HANDLE thread_handle = m_host_thread.GetNativeThread().GetSystemHandle();     do {       // ResumeThread returns -1 on error, or the thread's *previous* suspend       // count on success. This means that the return value is 1 when the thread       // was restarted. Note that DWORD is an unsigned int, so we need to       // explicitly compare with -1.       previous_suspend_count = ::ResumeThread(thread_handle);        if (previous_suspend_count == (DWORD)-1)         return Status(::GetLastError(), eErrorTypeWin32);      } while (previous_suspend_count > 1);   }    return Status(); } 

int main(int argc, const char **argv) {     /* ... */     while (TRUE) {         DEBUG_EVENT event;         BOOL should_stop = FALSE;         DWORD continue_flag = DBG_EXCEPTION_NOT_HANDLED;                  if (!WaitForDebugEvent(&event, INFINITE)) {             break;         }          switch (event.dwDebugEventCode) {              case CREATE_PROCESS_DEBUG_EVENT:                 if (SymInitialize(event.u.CreateProcessInfo.hProcess, NULL, FALSE)) {                     SymSetOptions(SYMOPT_LOAD_LINES);                     DWORD64 base =                       SymLoadModule(event.u.CreateProcessInfo.hProcess,                                      event.u.CreateProcessInfo.hFile,                                      event.u.CreateProcessInfo.lpImageName,                                      NULL,                                      (DWORD64)event.u.CreateProcessInfo.lpStartAddress,                                      0);                 }                 break;             /* ... */         }     }     return 0; } 

Выводим файл и номера строк внутри него.

static BOOL CALLBACK process_single_source_file(PSRCCODEINFO line, PVOID context) {     /* Файл:Строка (Адрес инструкции) */     printf("%s: %d (%llx)\n", line->FileName, line->LineNumber, line->Address);     return TRUE; }  static BOOL CALLBACK process_source_files_info(PSOURCEFILE file, PVOID context) {     DWORD64 base = (DWORD64)context;     if (!SymEnumLines(child_hProcess, base, NULL, NULL, process_single_source_file, context)) {         print_error("SymEnumLines");     }     printf("\n");     return TRUE; }  static void show_source_file_info(DWORD64 base) {     if (!SymEnumSourceFiles(child_hProcess, base, "*.c", process_source_files_info, (PVOID)base)) {         print_error("SymEnumSourceFiles");     } } 

static BOOL CALLBACK process_type_info(PSYMBOL_INFO symbol, ULONG symbol_size, PVOID context) {         /* 1 */     if (symbol->Tag != SymTagUDT) {         return TRUE;     }      /* 1.5 */     DWORD kind;      if (!SymGetTypeInfo(child_hProcess, symbol->ModBase, symbol->TypeIndex, TI_GET_UDTKIND, &kind)) {         return FALSE;     }      if (kind != UdtStruct && kind != UdtClass) {         return TRUE;     }          /* 2 */     DWORD childrenCount;     if (!SymGetTypeInfo(child_hProcess, symbol->ModBase, symbol->TypeIndex, TI_GET_CHILDRENCOUNT, &childrenCount)) {         return FALSE;     }      int findChildrenSize = sizeof(TI_FINDCHILDREN_PARAMS) + childrenCount * sizeof(ULONG);     TI_FINDCHILDREN_PARAMS *children = malloc(findChildrenSize);     memset(children, 0, findChildrenSize);     children->Count = childrenCount;      if (!SymGetTypeInfo(child_hProcess, symbol->ModBase, symbol->TypeIndex, TI_FINDCHILDREN, children)) {         return FALSE;     }      /* 3 */     printf("%s %s\n", kind == UdtClass ? "class" : "struct", symbol->Name);     for (DWORD i = 0; i < childrenCount; i++) {         /* 4 */         DWORD childTag;         if (!SymGetTypeInfo(child_hProcess, symbol->ModBase, children->ChildId[i], TI_GET_SYMTAG, &childTag)) {             return FALSE;         }          if (childTag != SymTagData) {             continue;         }          WCHAR *memberName;         if (!SymGetTypeInfo(child_hProcess, symbol->ModBase, children->ChildId[i], TI_GET_SYMNAME, &memberName)) {             return FALSE;         }          /* 5 */         DWORD typeId;         if (!SymGetTypeInfo(child_hProcess, symbol->ModBase, children->ChildId[i], TI_GET_TYPEID, &typeId)) {             return FALSE;         }          DWORD memberTypeTag;         if (!SymGetTypeInfo(child_hProcess, symbol->ModBase, typeId, TI_GET_SYMTAG, &memberTypeTag)) {             return FALSE;         }          /* 6 */         char *typeName;         if (memberTypeTag == SymTagBaseType) {             DWORD baseType;             if (!SymGetTypeInfo(child_hProcess, symbol->ModBase, typeId, TI_GET_BASETYPE, &baseType)) {                 return FALSE;             }              typeName = "unknown";             switch (baseType) {                 case btInt:                     typeName = "int";                     break;                 case btChar:                     typeName = "char";                     break;                 case btFloat:                     typeName = "float";                     break;             }         } else {             typeName = "*complex*";         }          printf("\t%s %ls\n", typeName, memberName);     }     printf("\n");          return TRUE; }  static void show_types_info(DWORD64 base, ULONG64 baseOfImage) {     if (!SymEnumTypes(child_hProcess, baseOfImage, process_type_info, (PVOID)base)) {         print_error("SymEnumTypes");     } } 

static void dump_callstack() {     CONTEXT ctx;     ctx.ContextFlags = CONTEXT_FULL;     if (!GetThreadContext(child_hThread, &ctx)) {         print_error("GetThreadContext");         return;     }     STACKFRAME stack = {0};     stack.AddrPC.Offset = ctx.Rip;     stack.AddrPC.Mode = AddrModeFlat;     stack.AddrFrame.Offset = ctx.Rbp;     stack.AddrFrame.Mode = AddrModeFlat;     stack.AddrStack.Offset = ctx.Rsp;     stack.AddrStack.Mode = AddrModeFlat;      do     {         if (!StackWalk(IMAGE_FILE_MACHINE_AMD64, child_hProcess, child_hThread, &stack, &ctx,                         NULL, SymFunctionTableAccess64, SymGetModuleBase64, NULL)) {             print_error("StackWalk");             return;         }         DWORD displacement;         IMAGEHLP_LINE64 line;         DWORD64 addr = stack.AddrPC.Offset;         if (SymGetLineFromAddr(child_hProcess, addr, &displacement, &line)) {             /* Файл:Строка */             printf("%s:%d\n", line.FileName, line.LineNumber);         }          if (GetLastError() == ERROR_MOD_NOT_FOUND) {             continue;         }     } while (stack.AddrReturn.Offset != 0); } 

Далее, буду показывать кода ассемблера. KolibriOS написан на FASM и в нем есть концепция макросов. Один из часто используемых — mcall. По сути, это просто макрос для системного вызова. Просто посмотрите на его определение и сами все поймете:

; https://github.com/KolibriOS/kolibrios/blob/975284f5f3deece4fe4ac0ac9227e6728a2f1d1f/programs/macros.inc#L297  macro mcall a,b,c,d,e,f,g {   ; [mike.dld], [Ghost]  local  ..ret_point  __mov eax,a  __mov ebx,b  __mov ecx,c  __mov edx,d  __mov esi,e  __mov edi,f  __mov ebp,g   if __CPU_type eq p5         int     0x40  else   if __CPU_type eq p6         push    ebp         mov     ebp, esp         push    ..ret_point     ; it may be 2 or 5 byte         sysenter  ..ret_point:         pop     edx         pop     ecx    else    if __CPU_type eq k6         push    ecx         syscall         pop     ecx    else         display 'ERROR : unknown CPU type (set to p5)', 10, 13         __CPU_type equ p5         int     0x40    end if   end if  end if } 

Вначале, мы выставляем аргументы системного вызова, а затем, в зависимости от архитектуры, соответствующую инструкцию для вызова ядра.

SF_WAIT_EVENT — это константа 10

; Входная точка  ; https://github.com/KolibriOS/kolibrios/blob/975284f5f3deece4fe4ac0ac9227e6728a2f1d1f/programs/develop/koldbg/koldbg.asm#L1663 Start:     ; ...      ; set event mask - default events and debugging events     mcall   40,EVM_REDRAW or EVM_KEY or EVM_BUTTON or EVM_DEBUG          ; ...  ; Ожидание следующего события и запуск обработчика для него  ; https://github.com/KolibriOS/kolibrios/blob/975284f5f3deece4fe4ac0ac9227e6728a2f1d1f/programs/develop/koldbg/koldbg.asm#L1720 WaitEvent:         push    SF_WAIT_EVENT         pop     eax         int     40h          cmp     al,9         jz      DebugMsg         dec     eax         jz      Redraw         dec     eax         jz      Key         sub     eax,4         jz      Mouse         ; Дальше код закрытия окна - обработчик EVM_BUTTON (т.к. кнопка одна - закрытие)  ; Событие отладки  ; https://github.com/KolibriOS/kolibrios/blob/975284f5f3deece4fe4ac0ac9227e6728a2f1d1f/programs/develop/koldbg/koldbg.asm#L1894 DebugMsg:         ; ...      DbgMsgStart:         ; ...      DbgNotify:         ; ...      ; Процесс завершился     Terminated:         ; ...      ; Исключение     Exception:          ; ...         .Int3:         .UserINT3:         .NotDbg:         .Suspended:         ; ...     DbgMsgEnd:         ; ...         jmp     WaitEvent  ; Перерисовка окна Redraw:         ; ...     .ReSize:         ; ...     .ReSizeDraw:         ; ...  ; Нажатие клавиши Key:         ; ...                  cmp     [DebuggeePID],0         jz      DoCommandLine         cmp     [CmdLineActive],0         jnz     GetCommandLine          jmp     WinSwitch          ; Step into     F7:          jz      .No         call    OnStep         .No:jmp     WaitEvent          ; Step over     F8:         jz      F7.No         call    OnProceed         jmp     F7.No  ; Кнопка мыши Mouse:         ; Обработка клика и двойного клика         jmp     WaitEvent  

; Статически аллоцированная структура  ; https://github.com/KolibriOS/kolibrios/blob/975284f5f3deece4fe4ac0ac9227e6728a2f1d1f/programs/develop/koldbg/koldbg.asm#L2698 FN70LoadBlock:  dd 7 ; Первое поле - это номер подфункции                 dd 1 ; Флаг - запуск под отладкой LoadParams      dd 0 ; Остальные поля заполняются в OnLoadInit                 dd 0                 dd 0 LoadName:       db 0                 rb 255   ; https://github.com/KolibriOS/kolibrios/blob/975284f5f3deece4fe4ac0ac9227e6728a2f1d1f/programs/develop/koldbg/koldbg.asm#L221  OnLoad: mov     esi,[CurArg] OnLoadInit:         ; ... DoReLoad:         ; ...                  ; Вызов 70,7         mcall   70,FN70LoadBlock         test    eax,eax         jns     .Loaded          ; ...      .Loaded:         ; Подгрузка отладочных символов         ; ...         mov     dword [ecx],'.dbg'         call    OnLoadSymbols.Silent    ; Try to load .dbg file         ; ...         mov     dword [ecx],'.map'      ; If failed, try .map file too         call    OnLoadSymbols.Silent         ret 

Можете заметить инструкции в конце. Они нужны для загрузки map файлов — символьной информации (адреса функций, переменных и другой символьной информации). Вначале, пробуется .dbg файл (генерируется FASM), а затем .map (генерируется GCC).

; https://github.com/KolibriOS/kolibrios/blob/975284f5f3deece4fe4ac0ac9227e6728a2f1d1f/programs/develop/koldbg/koldbg.asm#L2143  EnableBreakPoint:         ; ...         ; Сохраняем инструкцию         mcall   69,6,[DebuggeePID],1,[edi-5]         dec     eax         jnz     .Err          ; Та самая точка останова         push    0xCC         mov     edi,esp          ; 7 = 6 + 1         inc     ebx         ; Записываем инструкцию         mcall   69         pop     eax         ; ...     .DR:         ; Выставление аппаратной точки останова         ; ...         mcall   69,9,[DebuggeePID]         ; ... 

Можете заметить, что в конце имеется вызов 69,9 — это аппаратная точка останова.

; https://github.com/KolibriOS/kolibrios/blob/975284f5f3deece4fe4ac0ac9227e6728a2f1d1f/programs/develop/koldbg/koldbg.asm#L1894  DebugMsg:         ; ...      ; Обработчик исключения     Exception:       ; int3 command generates exception 0x0D, #GP         push    eax         cmp     al,0x0D         jnz     .NotDbg     ; check for 0xCC byte at eip         push    0         mcall   69,6,[DebuggeePID],1,[_EIP],esp         pop     eax         cmp     al,0xCC         je      .Int3     ; check for 0xCD03 word at eip         push    0         inc     edx         mcall   69;,6,[DebuggeePID],2,[_EIP],esp         pop     eax         cmp     ax,0x03CD         jne     .NotDbg         mov     eax,[_EIP]         inc     [_EIP]         inc     [_EIP]         jmp     .UserINT3     .Int3:     ; this is either dbg breakpoint or int3 cmd in debuggee         mov     eax,[_EIP]         call    FindEnabledBreakPoint         jnz     .UserINT3     ; dbg breakpoint; clear if one-shot         ; Обрабатываем точку останова         ; ...      .UserINT3:         ; Это пользовательская инструкция int3         ; ...      .NotDbg:         ; ...         jmp     WaitEvent  

Читая документацию к koldbg узнал, что точки останова называют бряки

Соответствующие условия называются точками останова, breakpoint(s), в просторечии — бряками.

; https://github.com/KolibriOS/kolibrios/blob/975284f5f3deece4fe4ac0ac9227e6728a2f1d1f/programs/develop/koldbg/koldbg.asm#L810 OnStep:         ; ...         ; Выставляем флаг TF         call    GetContext         or      byte [_EFL+1],1 ; set TF         call    SetContext         and     byte [_EFL+1],not 1                  ; if instruction at eip is "int xx", set one-shot breakpoint immediately after         mov     eax,[_EIP]         call    FindEnabledBreakPoint         jnz     @F         cmp     byte [edi+5],0xCD         jz      .Int      @@:         ; Проверяем следующую инструкцию         push    0         mcall   69,6,[DebuggeePID],3,[_EIP],esp         ; int XXX         cmp     eax,edx         pop     eax         jnz     .DoIt         cmp     al,0xCD         jz      .Int         ; syscall         cmp     ax,0x050F         jz      .SysCall         ; sysenter         cmp     ax,0x340F         jz      .SysEnter         ; resume process      .DoIt:         ret      ; return address is [ebp-4]     ; У SysEnter и SysCall логика примерно одинаковая - объединил     .SysEnter:     .SysCall:         and     byte [_EFL+1],not 1     ; clear TF - avoid system halt (!)         call    SetContext     ; Выставляем временную точку останова после     ; после текущей инструкции, если не выставлена     .Int:         mov     eax,[_EIP]         inc     eax         inc     eax     @@:         push    eax         call    FindEnabledBreakPoint         pop     eax         jz      .DoIt         ; there is no enabled breakpoint yet; set temporary breakpoint         mov     bl,5         call    AddBreakPoint         jmp     .DoIt 

; https://github.com/KolibriOS/kolibrios/blob/975284f5f3deece4fe4ac0ac9227e6728a2f1d1f/programs/develop/koldbg/koldbg.asm#L906  OnProceed:         ; ...      @@:         ; Если мы на точке останова, то выполняем step и заходим в нее         call    GetByteNoBreak         jc      OnStep         inc     esi          ; skip prefixes         call    IsPrefix         jz      @B         cmp     al,0xE8         ; call         jnz     @f         add     esi,4         jmp     .DoIt          ; Обнаруживаем особенные инструкции     ; Строковые     ; A4,A5 = movs; A6,A7 = cmps     @@:         cmp     al,0xA4         jb      @F         cmp     al,0xA8         jb      .DoIt      ; AA,AB = stos; AC,AD = lods; AE,AF = scas     @@:         cmp     al,0xAA         jb      @F         cmp     al,0xB0         jb      .DoIt      ; Циклы     ; E0 = loopnz; E1 = loopz; E2 = loop     @@:         cmp     al,0xE0         jb      .NoLoop         cmp     al,0xE2         ja      .NoLoop         inc     esi         jmp     .DoIt      ; Вызов функции     ; FF /2 = call     .NoLoop:         cmp     al,0xFF         jnz     OnStep          ; ...          ; Ставим временную точку останова и продолжаем выполнение     .DoIt:     ; insert one-shot breakpoint at esi and resume         call    GetByteNoBreak         jc      OnStep         mov     eax,esi         call    FindEnabledBreakPoint         jz      @F         mov     eax,esi         mov     bl,5         call    AddBreakPoint         jmp     OnStep.DoIt     @@:         ret 

; https://github.com/KolibriOS/kolibrios/blob/975284f5f3deece4fe4ac0ac9227e6728a2f1d1f/programs/develop/koldbg/koldbg.asm#L1022  IsPrefix:         cmp     al,0x64         ; fs:         jz      .Ret         cmp     al,0x65         ; gs:         jz      .Ret         cmp     al,0x66         ; use16/32         jz      .Ret         cmp     al,0x67         ; addr16/32         jz      .Ret         cmp     al,0xF0         ; lock         jz      .Ret         cmp     al,0xF2         ; repnz         jz      .Ret         cmp     al,0xF3         ; rep(z)         jz      .Ret         cmp     al,0x2E         ; cs:         jz      .Ret         cmp     al,0x36         ; ss:         jz      .Ret         cmp     al,0x3E         ; ds:         jz      .Ret         cmp     al,0x26         ; es:     .Ret:         ret 

В обработке исключения участвует множество функций. Я расположил их сверху вних, в порядке вызова.

/*   * Номер исключения  * https://github.com/torvalds/linux/blob/adc218676eef25575469234709c2d87185ca223a/arch/x86/include/asm/trapnr.h#L22  */ #define X86_TRAP_BP 3/* Breakpoint */  /*   * Регистрация IDT  * https://github.com/torvalds/linux/blob/adc218676eef25575469234709c2d87185ca223a/arch/x86/kernel/idt.c#L63  */ static const __initconst struct idt_data early_idts[] = {     /* ... */ SYSG(X86_TRAP_BP,asm_exc_int3),     /* ... */ };   /*   * Определение обработчика  * https://github.com/torvalds/linux/blob/adc218676eef25575469234709c2d87185ca223a/arch/x86/kernel/traps.c#L784  */ DEFINE_IDTENTRY_RAW(exc_int3) {     /* ... */ if (user_mode(regs)) { do_int3_user(regs); } else { if (!do_int3(regs)) die("int3", regs, 0); } }  /* https://github.com/torvalds/linux/blob/adc218676eef25575469234709c2d87185ca223a/arch/x86/kernel/traps.c#L774 */ static void do_int3_user(struct pt_regs *regs) {     /* ... */ do_trap(X86_TRAP_BP, SIGTRAP, "int3", regs, 0, 0, NULL);     /* ... */ }  /* https://github.com/torvalds/linux/blob/adc218676eef25575469234709c2d87185ca223a/arch/x86/kernel/traps.c#L191 */ static void do_trap(int trapnr, int signr, char *str, struct pt_regs *regs, long error_code, int sicode, void __user *addr) {     /* ... */ if (!sicode) force_sig(signr); else         /* ... */ } 

DebugMsg:         ; ...  ; https://github.com/KolibriOS/kolibrios/blob/975284f5f3deece4fe4ac0ac9227e6728a2f1d1f/programs/develop/koldbg/koldbg.asm#L1963 Exception:         ; ...     ; int3 command generates exception 0x0D, #GP         push    eax         cmp     al,0x0D         jnz     .NotDbg         ; ... 

; https://github.com/KolibriOS/kolibrios/blob/975284f5f3deece4fe4ac0ac9227e6728a2f1d1f/kernel/trunk/core/sys32.inc#L18 build_interrupt_table:         ; Создание таблицы IDT         mov     edi, idts         mov     esi, sys_int         mov     ecx, 0x40         mov     eax, (10001110b shl 24) + os_code   @@:         movsw   ; low word of code-entry         stosd   ; interrupt gate type : os_code selector         movsw   ; high word of code-entry         loop    @b         movsd   ; copy low  dword of trap gate for int 0x40         movsd   ; copy high dword of trap gate for int 0x40         mov     ecx, 23         mov     eax, (10001110b shl 24) + os_code   @@:         movsw   ; low word of code-entry         stosd   ; interrupt gate type : os_code selector         movsw   ; high word of code-entry         loop    @b          ; Регистрация таблицы         lidt    [esi]         ret  ; Статически выделенная область адресов обработчиков исключений   ; https://github.com/KolibriOS/kolibrios/blob/975284f5f3deece4fe4ac0ac9227e6728a2f1d1f/kernel/trunk/core/sys32.inc#L42 sys_int:     ; exception handlers addresses (for interrupt gate construction)         dd      e0,e1,e2,e3,e4,e5,e6,except_7 ; SEE: core/fpu.inc         dd      e8,e9,e10,e11,e12,e13,page_fault_exc,e15         dd      e16, e17,e18, e19         times   12 dd unknown_interrupt ;int_20..int_31  ; Шаблонный код функции обработчика исключений  ; https://github.com/KolibriOS/kolibrios/blob/975284f5f3deece4fe4ac0ac9227e6728a2f1d1f/kernel/trunk/core/sys32.inc#L94 macro exc_wo_code [num] {   e#num :         save_ring3_context         mov     bl, num         ; Обобщенный обработчик исключения         jmp     exc_c } exc_wo_code   0,1,2,3,4,5,6,15,16,19 

/* https://github.com/torvalds/linux/blob/adc218676eef25575469234709c2d87185ca223a/kernel/ptrace.c#L809 */ #define is_singlestep(request)((request) == PTRACE_SINGLESTEP)  /* https://github.com/torvalds/linux/blob/adc218676eef25575469234709c2d87185ca223a/kernel/ptrace.c#L823 */ static int ptrace_resume(struct task_struct *child, long request,  unsigned long data) {  if (/* ... */) { /* ... */ } else if (is_singlestep(request) || /* ... */) { if (unlikely(!arch_has_single_step())) return -EIO; user_enable_single_step(child); } else { /* ... */ }     /* ... */ return 0; }  /* https://github.com/torvalds/linux/blob/adc218676eef25575469234709c2d87185ca223a/arch/x86/kernel/step.c#L219 */ void user_enable_single_step(struct task_struct *child) { enable_step(child, 0); }  /* https://github.com/torvalds/linux/blob/adc218676eef25575469234709c2d87185ca223a/arch/x86/kernel/step.c#L204 */ static void enable_step(struct task_struct *child, bool block) { if (enable_single_step(child) && /* ... */) /* ... */ else if (/* ... */) /* ... */ }  /* https://github.com/torvalds/linux/blob/adc218676eef25575469234709c2d87185ca223a/arch/x86/kernel/step.c#L113 */ static int enable_single_step(struct task_struct *child) { struct pt_regs *regs = task_pt_regs(child);      /* ... */  /* Set TF on the kernel stack.. */ regs->flags |= X86_EFLAGS_TF;      /* ... */ return 1; } 

/* https://sourceware.org/git/?p=binutils-gdb.git;a=blob;f=gdb/nat/x86-dregs.c;h=7ea9f49eb680955ffffc9132d67b2aebd773f941;hb=23c84db5b3cb4e8a0d555c76e1a0ab56dc8355f3#l504 */ int x86_dr_insert_watchpoint (struct x86_debug_reg_state *state,               enum target_hw_bp_type type,               CORE_ADDR addr, int len) {     int retval;     /* Work on a local copy of the debug registers, and on success,        commit the change back to the inferior.  */     struct x86_debug_reg_state local_state = *state;      if (type == hw_read)         return 1; /* unsupported */      if (((len != 1 && len != 2 && len != 4)          && !(TARGET_HAS_DR_LEN_8 && len == 8))         || addr % len != 0)     {         retval = x86_handle_nonaligned_watchpoint (&local_state,                                                    WP_INSERT,                                                    addr, len, type);     }     else     {         unsigned len_rw = x86_length_and_rw_bits (len, type);          retval = x86_insert_aligned_watchpoint (&local_state,                                                 addr, len_rw);     }      if (retval == 0)         x86_update_inferior_debug_regs (state, &local_state);      if (show_debug_regs)         x86_show_dr (state, "insert_watchpoint", addr, len, type);    return retval; }  /* https://sourceware.org/git/?p=binutils-gdb.git;a=blob;f=gdb/nat/x86-dregs.c;h=7ea9f49eb680955ffffc9132d67b2aebd773f941;hb=23c84db5b3cb4e8a0d555c76e1a0ab56dc8355f3#l304 */ static int x86_insert_aligned_watchpoint (struct x86_debug_reg_state *state,        CORE_ADDR addr, unsigned len_rw_bits) {     int i;        if (!x86_dr_low_can_set_addr () || !x86_dr_low_can_set_control ())       return -1;        /* First, look for an occupied debug register with the same address        and the same RW and LEN definitions.  If we find one, we can        reuse it for this watchpoint as well (and save a register).  */     ALL_DEBUG_ADDRESS_REGISTERS (i)     {         if (!X86_DR_VACANT (state, i)             && state->dr_mirror[i] == addr           && X86_DR_GET_RW_LEN (state->dr_control_mirror, i) == len_rw_bits)         {             state->dr_ref_count[i]++;             return 0;         }     }        /* Next, look for a vacant debug register.  */     ALL_DEBUG_ADDRESS_REGISTERS (i)     {         if (X86_DR_VACANT (state, i))           break;     }        /* No more debug registers!  */     if (i >= DR_NADDR)         return -1;        /* Now set up the register I to watch our region.  */        /* Record the info in our local mirrored array.  */     state->dr_mirror[i] = addr;     state->dr_ref_count[i] = 1;     X86_DR_SET_RW_LEN (state, i, len_rw_bits);     /* Note: we only enable the watchpoint locally, i.e. in the current        task.  Currently, no x86 target allows or supports global        watchpoints; however, if any target would want that in the        future, GDB should probably provide a command to control whether        to enable watchpoints globally or locally, and the code below        should use global or local enable and slow-down flags as        appropriate.  */     X86_DR_LOCAL_ENABLE (state, i);     state->dr_control_mirror |= DR_LOCAL_SLOWDOWN;     state->dr_control_mirror &= X86_DR_CONTROL_MASK;        return 0; }  /* https://sourceware.org/git/?p=binutils-gdb.git;a=blob;f=gdb/nat/x86-linux-dregs.c;h=a6c0ea63552d6563d3da0f578bc759eae0706828;hb=23c84db5b3cb4e8a0d555c76e1a0ab56dc8355f3#l139 */ void x86_linux_update_debug_registers (struct lwp_info *lwp) {     ptid_t ptid = ptid_of_lwp (lwp);     int clear_status = 0;        gdb_assert (lwp_is_stopped (lwp));        if (lwp_debug_registers_changed (lwp))     {         struct x86_debug_reg_state *state = x86_debug_reg_state (ptid.pid ());         int i;            /* Prior to Linux kernel 2.6.33 commit            72f674d203cd230426437cdcf7dd6f681dad8b0d, setting DR0-3 to            a value that did not match what was enabled in DR_CONTROL            resulted in EINVAL.  To avoid this we zero DR_CONTROL before            writing address registers, only writing DR_CONTROL's actual            value once all the addresses are in place.  */         x86_linux_dr_set (ptid, DR_CONTROL, 0);            ALL_DEBUG_ADDRESS_REGISTERS (i)       if (state->dr_ref_count[i] > 0)       {           x86_linux_dr_set (ptid, i, state->dr_mirror[i]);              /* If we're setting a watchpoint, any change the inferior              has made to its debug registers needs to be discarded              to avoid x86_stopped_data_address getting confused.  */           clear_status = 1;       }            /* If DR_CONTROL is supposed to be zero then it's already set.  */         if (state->dr_control_mirror != 0)           x86_linux_dr_set (ptid, DR_CONTROL, state->dr_control_mirror);            lwp_set_debug_registers_changed (lwp, 0);     }        if (clear_status         || lwp_stop_reason (lwp) == TARGET_STOPPED_BY_WATCHPOINT)         x86_linux_dr_set (ptid, DR_STATUS, 0); }  /* https://sourceware.org/git/?p=binutils-gdb.git;a=blob;f=gdb/nat/x86-linux-dregs.c;h=a6c0ea63552d6563d3da0f578bc759eae0706828;hb=23c84db5b3cb4e8a0d555c76e1a0ab56dc8355f3#l58 */ static void x86_linux_dr_set (ptid_t ptid, int regnum, unsigned long value) {     int tid;      gdb_assert (ptid.lwp_p ());     tid = ptid.lwp ();      errno = 0;     ptrace (PTRACE_POKEUSER, tid, u_debugreg_offset (regnum), value);     if (errno != 0)       perror_with_name (_("Couldn't write debug register")); } 

В ARMV8 определяется 4 уровня исключений и каждый соответствует какому-либо уровню привилегий (как кольца защиты в x86):

• EL0 — приложения

• EL1 — ядро ОС

• EL2 — гипервизор

• EL3 — монитор безопасности

При обработке исключения его уровень может быть повышен, а при возвращении — понижен. То же самое касается и AArchXXX — при обработке возможен переход AArch32 -> AArch64, и наоборот при возвращении.

Также, в ARM имеется несколько Link регистров. Они хранят адреса возврата при вызове функции. А для исключений имеются собственные Exception Link регистры. Всего их 3, для каждого уровня, начиная с 1: ELR_EL1, ELR_EL2, ELR_EL3. В них хранятся адреса для возврата на предыдущий уровень.

Про уровни исключений можно почитать в этой статье.

Напомню, что за платформно-зависимые части вынесены в отдельные классы/функции. Поэтому реализация выставления точки останова реализована так: обобщенная функция получает инструкцию точки останова (массив байт), а потом записывает по указанному адресу.

/* https://sourceware.org/git/?p=binutils-gdb.git;a=blob;f=gdb/aarch64-tdep.c;h=e4bca6c66323b1da1df6a73bb3d49992b2822f2b;hb=23c84db5b3cb4e8a0d555c76e1a0ab56dc8355f3#l2520 */  /* AArch64 BRK software debug mode instruction.    Note that AArch64 code is always little-endian.    1101.0100.0010.0000.0000.0000.0000.0000 = 0xd4200000.  */ constexpr gdb_byte aarch64_default_breakpoint[] = {0x00, 0x00, 0x20, 0xd4};  /* https://sourceware.org/git/?p=binutils-gdb.git;a=blob;f=gdb/arch-utils.h;h=40c62f30a65fbf86a1644ae24ef3f6ec329fd87f;hb=23c84db5b3cb4e8a0d555c76e1a0ab56dc8355f3#l31 */ template <size_t bp_size,   const gdb_byte *break_insn_little,   const gdb_byte *break_insn_big> struct bp_manipulation_endian {   static int   kind_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr)   {     return bp_size;   }    static const gdb_byte *   bp_from_kind (struct gdbarch *gdbarch, int kind, int *size)   {     *size = kind;     if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)       return break_insn_big;     else       return break_insn_little;   } };  #define BP_MANIPULATION(BREAK_INSN) \   bp_manipulation<sizeof (BREAK_INSN), BREAK_INSN>  typedef BP_MANIPULATION (aarch64_default_breakpoint) aarch64_breakpoint;  /* https://sourceware.org/git/?p=binutils-gdb.git;a=blob;f=gdb/mem-break.c;h=712ad000daf167cd7a7154463da600b5b07cc300;hb=23c84db5b3cb4e8a0d555c76e1a0ab56dc8355f3#l37 */ int default_memory_insert_breakpoint (struct gdbarch *gdbarch,   struct bp_target_info *bp_tgt) {     CORE_ADDR addr = bp_tgt->placed_address;     const unsigned char *bp;     gdb_byte *readbuf;     int bplen;     int val;        /* Determine appropriate breakpoint contents and size for this address.  */     bp = gdbarch_sw_breakpoint_from_kind (gdbarch, bp_tgt->kind, &bplen);      /* Save the memory contents in the shadow_contents buffer and then        write the breakpoint instruction.  */     readbuf = (gdb_byte *) alloca (bplen);     val = target_read_memory (addr, readbuf, bplen);     if (val == 0)     {         /* ... */         val = target_write_raw_memory (addr, bp, bplen);     }      return val; } 

/* https://github.com/torvalds/linux/blob/adc218676eef25575469234709c2d87185ca223a/arch/arm64/include/asm/esr.h#L67 */ #define ESR_ELx_EC_BRK64UL(0x3C) #define ESR_ELx_EC(esr)(((esr) & ESR_ELx_EC_MASK) >> ESR_ELx_EC_SHIFT)  /* https://github.com/torvalds/linux/blob/adc218676eef25575469234709c2d87185ca223a/arch/arm64/kernel/entry-common.c#L485 */ asmlinkage void noinstr el1h_64_sync_handler(struct pt_regs *regs) { unsigned long esr = read_sysreg(esr_el1);  switch (ESR_ELx_EC(esr)) { /* ... */ case ESR_ELx_EC_BREAKPT_CUR: case ESR_ELx_EC_SOFTSTP_CUR: case ESR_ELx_EC_WATCHPT_CUR: case ESR_ELx_EC_BRK64: el1_dbg(regs, esr); break;     /* ... */ } }  /* https://github.com/torvalds/linux/blob/adc218676eef25575469234709c2d87185ca223a/arch/arm64/kernel/entry-common.c#L466 */ static void noinstr el1_dbg(struct pt_regs *regs, unsigned long esr) { unsigned long far = read_sysreg(far_el1);  if (/* ... */) do_debug_exception(far, esr, regs); } 

/* https://github.com/llvm/llvm-project/blob/6d34cfac53b993a6cdf3d6669e017eac3a2296c8/lldb/source/Plugins/Process/Windows/Common/NativeThreadWindows.cpp#L46 */ Status TargetThreadWindows::DoResume() {   /* ... */   if (resume_state == eStateStepping) {     const ArchSpec &arch = process->GetTarget().GetArchitecture();     switch (arch.GetMachine()) {     case llvm::Triple::x86:     case llvm::Triple::x86_64:       flags_value |= 0x100; // Set the trap flag on the CPU       break;     case llvm::Triple::aarch64:     case llvm::Triple::arm:     case llvm::Triple::thumb:       flags_value |= 0x200000; // The SS bit in PState       break;     }   }   /* ... */ } 

/* https://github.com/torvalds/linux/blob/adc218676eef25575469234709c2d87185ca223a/kernel/ptrace.c#L823 */ static int ptrace_resume(struct task_struct *child, long request,  unsigned long data) { if (/* ... */) {         /* ... */ } else if (is_singlestep(request) || is_sysemu_singlestep(request)) { user_enable_single_step(child); } else {         /* ... */ } }  /* https://github.com/torvalds/linux/blob/adc218676eef25575469234709c2d87185ca223a/arch/arm64/kernel/debug-monitors.c#L445 */ void user_enable_single_step(struct task_struct *task) { struct thread_info *ti = task_thread_info(task);  if (!test_and_set_ti_thread_flag(ti, TIF_SINGLESTEP))         set_user_regs_spsr_ss(user_regs); }  #define DBG_SPSR_SS(1 << 21)  /* https://github.com/torvalds/linux/blob/adc218676eef25575469234709c2d87185ca223a/arch/arm64/kernel/debug-monitors.c#L144 */ static void set_user_regs_spsr_ss(struct user_pt_regs *regs) { regs->pstate |= DBG_SPSR_SS; } 

/* https://sourceware.org/git/?p=binutils-gdb.git;a=blob;f=gdb/aarch64-tdep.c;h=e4bca6c66323b1da1df6a73bb3d49992b2822f2b;hb=23c84db5b3cb4e8a0d555c76e1a0ab56dc8355f3#l3450 */ static std::vector<CORE_ADDR> aarch64_software_single_step (struct regcache *regcache) {   struct gdbarch *gdbarch = regcache->arch ();   enum bfd_endian byte_order_for_code = gdbarch_byte_order_for_code (gdbarch);   const int insn_size = 4;   const int atomic_sequence_length = 16; /* Instruction sequence length.  */   CORE_ADDR pc = regcache_read_pc (regcache);   CORE_ADDR breaks[2] = { CORE_ADDR_MAX, CORE_ADDR_MAX };   CORE_ADDR loc = pc;   CORE_ADDR closing_insn = 0;   uint32_t insn = read_memory_unsigned_integer (loc, insn_size, byte_order_for_code);   int index;   int insn_count;   int bc_insn_count = 0; /* Conditional branch instruction count.  */   int last_breakpoint = 0; /* Defaults to 0 (no breakpoints placed).  */   aarch64_inst inst;    if (aarch64_decode_insn (insn, &inst, 1, NULL) != 0)     return {};    /* Look for a Load Exclusive instruction which begins the sequence.  */   if (inst.opcode->iclass != ldstexcl || bit (insn, 22) == 0)     return {};    for (insn_count = 0; insn_count < atomic_sequence_length; ++insn_count)     {       loc += insn_size;       insn = read_memory_unsigned_integer (loc, insn_size,    byte_order_for_code);        if (aarch64_decode_insn (insn, &inst, 1, NULL) != 0) return {};       /* Check if the instruction is a conditional branch.  */       if (inst.opcode->iclass == condbranch) {   if (bc_insn_count >= 1)     return {};    /* It is, so we'll try to set a breakpoint at the destination.  */   breaks[1] = loc + inst.operands[0].imm.value;    bc_insn_count++;   last_breakpoint++; }        /* Look for the Store Exclusive which closes the atomic sequence.  */       if (inst.opcode->iclass == ldstexcl && bit (insn, 22) == 0) {   closing_insn = loc;   break; }     }    /* We didn't find a closing Store Exclusive instruction, fall back.  */   if (!closing_insn)     return {};    /* Insert breakpoint after the end of the atomic sequence.  */   breaks[0] = loc + insn_size;    /* Check for duplicated breakpoints, and also check that the second      breakpoint is not within the atomic sequence.  */   if (last_breakpoint       && (breaks[1] == breaks[0]   || (breaks[1] >= pc && breaks[1] <= closing_insn)))     last_breakpoint = 0;    std::vector<CORE_ADDR> next_pcs;    /* Insert the breakpoint at the end of the sequence, and one at the      destination of the conditional branch, if it exists.  */   for (index = 0; index <= last_breakpoint; index++)     next_pcs.push_back (breaks[index]);    return next_pcs; } 

Небольшое замечание: в коде gdb вы не найдете прямого упоминания регистров DBGWCR/DBGWVR, вместо этого используется специальная структура, отображаемая на эти регистры. Работа ведется с ней, а после этот кэш сбрасывается.

/* https://sourceware.org/git/?p=binutils-gdb.git;a=blob;f=gdb/nat/aarch64-hw-point.h;h=0d50eaab0dec8baf111fc2f22e3163be9f5e3de9;hb=23c84db5b3cb4e8a0d555c76e1a0ab56dc8355f3#l33 */ #define AARCH64_HBP_MAX_NUM 16 #define AARCH64_HWP_MAX_NUM 16  #define AARCH64_HBP_ALIGNMENT 4 #define AARCH64_HWP_ALIGNMENT 8  struct aarch64_debug_reg_state {   /* hardware breakpoint */   CORE_ADDR dr_addr_bp[AARCH64_HBP_MAX_NUM];   unsigned int dr_ctrl_bp[AARCH64_HBP_MAX_NUM];   unsigned int dr_ref_count_bp[AARCH64_HBP_MAX_NUM];    /* hardware watchpoint */   /* Address aligned down to AARCH64_HWP_ALIGNMENT.  */   CORE_ADDR dr_addr_wp[AARCH64_HWP_MAX_NUM];   /* Address as entered by user without any forced alignment.  */   CORE_ADDR dr_addr_orig_wp[AARCH64_HWP_MAX_NUM];   unsigned int dr_ctrl_wp[AARCH64_HWP_MAX_NUM];   unsigned int dr_ref_count_wp[AARCH64_HWP_MAX_NUM]; };   /* https://sourceware.org/git/?p=binutils-gdb.git;a=blob;f=gdb/nat/aarch64-hw-point.c;h=6acee0fb814c48ac43e127254f811397802f0682;hb=23c84db5b3cb4e8a0d555c76e1a0ab56dc8355f3#l299 */ static int aarch64_dr_state_insert_one_point (struct aarch64_debug_reg_state *state,    enum target_hw_bp_type type,    CORE_ADDR addr, int offset, int len,    CORE_ADDR addr_orig) {   int i, idx, num_regs, is_watchpoint;   unsigned int ctrl, *dr_ctrl_p, *dr_ref_count;   CORE_ADDR *dr_addr_p, *dr_addr_orig_p;    /* Set up state pointers.  */   is_watchpoint = (type != hw_execute);   if (is_watchpoint)     {       num_regs = aarch64_num_wp_regs;       dr_addr_p = state->dr_addr_wp;       dr_addr_orig_p = state->dr_addr_orig_wp;       dr_ctrl_p = state->dr_ctrl_wp;       dr_ref_count = state->dr_ref_count_wp;     }   else     {       num_regs = aarch64_num_bp_regs;       dr_addr_p = state->dr_addr_bp;       dr_addr_orig_p = nullptr;       dr_ctrl_p = state->dr_ctrl_bp;       dr_ref_count = state->dr_ref_count_bp;     }    ctrl = aarch64_point_encode_ctrl_reg (type, offset, len);    /* Find an existing or free register in our cache.  */   idx = -1;   for (i = 0; i < num_regs; ++i)     {       if ((dr_ctrl_p[i] & 1) == 0) {   idx = i;   /* no break; continue hunting for an exising one.  */ }       else if (dr_addr_p[i] == addr        && (dr_addr_orig_p == nullptr || dr_addr_orig_p[i] == addr_orig)        && dr_ctrl_p[i] == ctrl) {   idx = i;   break; }     }    /* No space.  */   if (idx == -1)     return -1;    /* Update our cache.  */   if ((dr_ctrl_p[idx] & 1) == 0)     {       /* new entry */       dr_addr_p[idx] = addr;       if (dr_addr_orig_p != nullptr) dr_addr_orig_p[idx] = addr_orig;       dr_ctrl_p[idx] = ctrl;       dr_ref_count[idx] = 1;       /* Notify the change.  */       aarch64_notify_debug_reg_change (state, is_watchpoint, idx);     }   else     {       /* existing entry */       dr_ref_count[idx]++;     }    return 0; } 

/* https://github.com/torvalds/linux/blob/adc218676eef25575469234709c2d87185ca223a/arch/powerpc/include/asm/reg.h#L800 */ #define   SRR1_PROGTRAP0x00020000 /* Trap */  /* https://github.com/torvalds/linux/blob/adc218676eef25575469234709c2d87185ca223a/arch/powerpc/kernel/traps.c#L1626 */ DEFINE_INTERRUPT_HANDLER(program_check_exception) { do_program_check(regs); }  /* https://github.com/torvalds/linux/blob/adc218676eef25575469234709c2d87185ca223a/arch/powerpc/kernel/traps.c#L593 */ #define REASON_TRAPSRR1_PROGTRAP  /* https://github.com/torvalds/linux/blob/adc218676eef25575469234709c2d87185ca223a/arch/powerpc/kernel/traps.c#L1479 */ static void do_program_check(struct pt_regs *regs) { unsigned int reason = get_reason(regs);  if (reason & REASON_TRAP) { /* ... */  /* User mode considers other cases after enabling IRQs */ if (!user_mode(regs)) { _exception(SIGTRAP, regs, TRAP_BRKPT, regs->nip); return; } }      /* ... */  if (reason & REASON_TRAP) { /* ... */ _exception(SIGTRAP, regs, TRAP_BRKPT, regs->nip); return; }  /* ... */ }  /* https://github.com/torvalds/linux/blob/adc218676eef25575469234709c2d87185ca223a/arch/powerpc/kernel/traps.c#L368 */ void _exception(int signr, struct pt_regs *regs, int code, unsigned long addr) {     /* ... */ force_sig_fault(signr, code, (void __user *)addr); }  /* https://github.com/torvalds/linux/blob/adc218676eef25575469234709c2d87185ca223a/kernel/signal.c#L1733 */ int force_sig_fault(int sig, int code, void __user *addr) { return force_sig_fault_to_task(sig, code, addr, current); }  /* https://github.com/torvalds/linux/blob/adc218676eef25575469234709c2d87185ca223a/kernel/signal.c#L1720 */ int force_sig_fault_to_task(int sig, int code, void __user *addr,     struct task_struct *t) { struct kernel_siginfo info;  clear_siginfo(&info); info.si_signo = sig; info.si_errno = 0; info.si_code  = code; info.si_addr  = addr; return force_sig_info_to_task(&info, t, HANDLER_CURRENT); } 

Если посмотрите на код, то можете заметить, что для маски Trap используется 0x00020000. Но если выставить в 64 битном числе выставить 46 бит в 1, то будет не то же самое. Причина в том, что в документации все биты записываются с конца. Если мы выставим бит 18 (64 — 46), то получим указанное значение.

/* https://github.com/torvalds/linux/blob/adc218676eef25575469234709c2d87185ca223a/arch/powerpc/kernel/traps.c#L1150 */ DEFINE_INTERRUPT_HANDLER(single_step_exception) { __single_step_exception(regs); }  /* https://github.com/torvalds/linux/blob/adc218676eef25575469234709c2d87185ca223a/arch/powerpc/kernel/traps.c#L583 */ #define clear_single_step(regs)(regs_set_return_msr((regs), (regs)->msr & ~MSR_SE)) #define clear_br_trace(regs)(regs_set_return_msr((regs), (regs)->msr & ~MSR_BE))  /* https://github.com/torvalds/linux/blob/adc218676eef25575469234709c2d87185ca223a/arch/powerpc/kernel/traps.c#L1133 */ static void __single_step_exception(struct pt_regs *regs) { clear_single_step(regs); clear_br_trace(regs);  /* ... */  _exception(SIGTRAP, regs, TRAP_TRACE, regs->nip); } 

/* https://github.com/torvalds/linux/blob/adc218676eef25575469234709c2d87185ca223a/arch/powerpc/include/uapi/asm/ptrace.h#L199 */ #define PPC_PTRACE_GETHWDBGINFO0x89 #define PPC_PTRACE_SETHWDEBUG0x88 #define PPC_PTRACE_DELHWDEBUG0x87  /* https://github.com/torvalds/linux/blob/adc218676eef25575469234709c2d87185ca223a/arch/powerpc/kernel/ptrace/ptrace.c#L40 */ long arch_ptrace(struct task_struct *child, long request,  unsigned long addr, unsigned long data) { void __user *datavp = (void __user *) data; unsigned long __user *datalp = datavp;  switch (request) { /* ... */ case PPC_PTRACE_SETHWDEBUG: { struct ppc_hw_breakpoint bp_info;  if (copy_from_user(&bp_info, datavp, sizeof(struct ppc_hw_breakpoint))) return -EFAULT; return ppc_set_hwdebug(child, &bp_info); } } }  /* https://github.com/torvalds/linux/blob/adc218676eef25575469234709c2d87185ca223a/arch/powerpc/kernel/ptrace/ptrace-noadv.c#L193 */ long ppc_set_hwdebug(struct task_struct *child, struct ppc_hw_breakpoint *bp_info) { int i; int len = 0; struct thread_struct *thread = &child->thread; struct perf_event *bp; struct perf_event_attr attr; struct arch_hw_breakpoint brk;  if (bp_info->version != 1) return -ENOTSUPP; /*  * We only support one data breakpoint  */ if ((bp_info->trigger_type & PPC_BREAKPOINT_TRIGGER_RW) == 0 ||     (bp_info->trigger_type & ~PPC_BREAKPOINT_TRIGGER_RW) != 0 ||     bp_info->condition_mode != PPC_BREAKPOINT_CONDITION_NONE) return -EINVAL;  if ((unsigned long)bp_info->addr >= TASK_SIZE) return -EIO;  brk.address = ALIGN_DOWN(bp_info->addr, HW_BREAKPOINT_SIZE); brk.type = HW_BRK_TYPE_TRANSLATE | HW_BRK_TYPE_PRIV_ALL; brk.len = DABR_MAX_LEN; brk.hw_len = DABR_MAX_LEN; if (bp_info->trigger_type & PPC_BREAKPOINT_TRIGGER_READ) brk.type |= HW_BRK_TYPE_READ; if (bp_info->trigger_type & PPC_BREAKPOINT_TRIGGER_WRITE) brk.type |= HW_BRK_TYPE_WRITE; if (bp_info->addr_mode == PPC_BREAKPOINT_MODE_RANGE_INCLUSIVE) len = bp_info->addr2 - bp_info->addr; else if (bp_info->addr_mode == PPC_BREAKPOINT_MODE_EXACT) len = 1; else return -EINVAL;  i = find_empty_ptrace_bp(thread); if (i < 0) return -ENOSPC;  /* Create a new breakpoint request if one doesn't exist already */ hw_breakpoint_init(&attr); attr.bp_addr = (unsigned long)bp_info->addr; attr.bp_len = len; arch_bp_generic_fields(brk.type, &attr.bp_type);  bp = register_user_hw_breakpoint(&attr, ptrace_triggered, NULL, child); thread->ptrace_bps[i] = bp; if (IS_ERR(bp)) { thread->ptrace_bps[i] = NULL; return PTR_ERR(bp); }  return i + 1; }  /* https://github.com/torvalds/linux/blob/adc218676eef25575469234709c2d87185ca223a/arch/powerpc/kernel/process.c#L805 */ static inline int set_dabr(struct arch_hw_breakpoint *brk) { unsigned long dabr, dabrx;  dabr = brk->address | (brk->type & HW_BRK_TYPE_DABR); dabrx = ((brk->type >> 3) & 0x7);  if (ppc_md.set_dabr) return ppc_md.set_dabr(dabr, dabrx);  if (IS_ENABLED(CONFIG_PPC_ADV_DEBUG_REGS)) { mtspr(SPRN_DAC1, dabr); if (IS_ENABLED(CONFIG_PPC_47x)) isync(); return 0; } else if (IS_ENABLED(CONFIG_PPC_BOOK3S)) { mtspr(SPRN_DABR, dabr); if (cpu_has_feature(CPU_FTR_DABRX)) mtspr(SPRN_DABRX, dabrx); return 0; } else { return -EINVAL; } }  /* https://github.com/torvalds/linux/blob/adc218676eef25575469234709c2d87185ca223a/arch/powerpc/include/asm/reg.h#L1399 */ #define mtspr(rn, v)asm volatile("mtspr " __stringify(rn) ",%0" : \      : "r" ((unsigned long)(v)) \      : "memory") 

Замечания:

1. Существует еще 1 регистр для точек останова — DABRX. В ней хранится маска привилегий. Но сейчас это не важно, поэтому опустил

2. В конце находится сама функция, которая выставляет значения регистров. В ней используется функция mtspr. На самом деле это обертка над одноименной инструкцией. Она необходима для выставления значений регистров, зависящих от реализации. А так как DABR — это регистр добавляемый в расширении, то использовать необходимо его.

3. Существует несколько версий архитектуры и для них используются разные способы выставления точки останова, поэтому имеются различные способы ее обработки.

/* https://github.com/torvalds/linux/blob/adc218676eef25575469234709c2d87185ca223a/arch/loongarch/kernel/traps.c#L703 */ asmlinkage void noinstr do_bp(struct pt_regs *regs) { bool user = user_mode(regs); unsigned int opcode, bcode; unsigned long era = exception_era(regs); irqentry_state_t state = irqentry_enter(regs);  if (regs->csr_prmd & CSR_PRMD_PIE) local_irq_enable();  if (__get_inst(&opcode, (u32 *)era, user)) goto out_sigsegv;  bcode = (opcode & 0x7fff);  /*  * notify the kprobe handlers, if instruction is likely to  * pertain to them.  */ switch (bcode) { case BRK_KDB: if (kgdb_breakpoint_handler(regs)) goto out; else break; case BRK_KPROBE_BP: if (kprobe_breakpoint_handler(regs)) goto out; else break; case BRK_KPROBE_SSTEPBP: if (kprobe_singlestep_handler(regs)) goto out; else break; case BRK_UPROBE_BP: if (uprobe_breakpoint_handler(regs)) goto out; else break; case BRK_UPROBE_XOLBP: if (uprobe_singlestep_handler(regs)) goto out; else break; default: current->thread.trap_nr = read_csr_excode(); if (notify_die(DIE_TRAP, "Break", regs, bcode,        current->thread.trap_nr, SIGTRAP) == NOTIFY_STOP) goto out; else break; }  switch (bcode) { case BRK_BUG: bug_handler(regs); break; case BRK_DIVZERO: die_if_kernel("Break instruction in kernel code", regs); force_sig_fault(SIGFPE, FPE_INTDIV, (void __user *)regs->csr_era); break; case BRK_OVERFLOW: die_if_kernel("Break instruction in kernel code", regs); force_sig_fault(SIGFPE, FPE_INTOVF, (void __user *)regs->csr_era); break; default: die_if_kernel("Break instruction in kernel code", regs); force_sig_fault(SIGTRAP, TRAP_BRKPT, (void __user *)regs->csr_era); break; }  out: if (regs->csr_prmd & CSR_PRMD_PIE) local_irq_disable();  irqentry_exit(regs, state); return;  out_sigsegv: force_sig(SIGSEGV); goto out; } 

/* https://github.com/torvalds/linux/blob/adc218676eef25575469234709c2d87185ca223a/arch/loongarch/kernel/hw_breakpoint.c#L174 */ static int hw_breakpoint_control(struct perf_event *bp,  enum hw_breakpoint_ops ops) { u32 ctrl, privilege; int i, max_slots, enable; struct pt_regs *regs; struct perf_event **slots; struct arch_hw_breakpoint *info = counter_arch_bp(bp);  if (arch_check_bp_in_kernelspace(info)) privilege = CTRL_PLV0_ENABLE; else privilege = CTRL_PLV3_ENABLE;  /*  Whether bp belongs to a task. */ if (bp->hw.target) regs = task_pt_regs(bp->hw.target);  if (info->ctrl.type == LOONGARCH_BREAKPOINT_EXECUTE) { /* Breakpoint */ slots = this_cpu_ptr(bp_on_reg); max_slots = boot_cpu_data.watch_ireg_count; } else { /* Watchpoint */ slots = this_cpu_ptr(wp_on_reg); max_slots = boot_cpu_data.watch_dreg_count; }  i = hw_breakpoint_slot_setup(slots, max_slots, bp, ops);  if (WARN_ONCE(i < 0, "Can't find any breakpoint slot")) return i;  switch (ops) { case HW_BREAKPOINT_INSTALL: /* Set the FWPnCFG/MWPnCFG 1~4 register. */ if (info->ctrl.type == LOONGARCH_BREAKPOINT_EXECUTE) { write_wb_reg(CSR_CFG_ADDR, i, 0, info->address); write_wb_reg(CSR_CFG_MASK, i, 0, info->mask); write_wb_reg(CSR_CFG_ASID, i, 0, 0); write_wb_reg(CSR_CFG_CTRL, i, 0, privilege); } else { write_wb_reg(CSR_CFG_ADDR, i, 1, info->address); write_wb_reg(CSR_CFG_MASK, i, 1, info->mask); write_wb_reg(CSR_CFG_ASID, i, 1, 0); ctrl = encode_ctrl_reg(info->ctrl); write_wb_reg(CSR_CFG_CTRL, i, 1, ctrl | privilege); } enable = csr_read64(LOONGARCH_CSR_CRMD); csr_write64(CSR_CRMD_WE | enable, LOONGARCH_CSR_CRMD); if (bp->hw.target && test_tsk_thread_flag(bp->hw.target, TIF_LOAD_WATCH)) regs->csr_prmd |= CSR_PRMD_PWE; break; case HW_BREAKPOINT_UNINSTALL: /* Reset the FWPnCFG/MWPnCFG 1~4 register. */ if (info->ctrl.type == LOONGARCH_BREAKPOINT_EXECUTE) { write_wb_reg(CSR_CFG_ADDR, i, 0, 0); write_wb_reg(CSR_CFG_MASK, i, 0, 0); write_wb_reg(CSR_CFG_CTRL, i, 0, 0); write_wb_reg(CSR_CFG_ASID, i, 0, 0); } else { write_wb_reg(CSR_CFG_ADDR, i, 1, 0); write_wb_reg(CSR_CFG_MASK, i, 1, 0); write_wb_reg(CSR_CFG_CTRL, i, 1, 0); write_wb_reg(CSR_CFG_ASID, i, 1, 0); } if (bp->hw.target) regs->csr_prmd &= ~CSR_PRMD_PWE; break; }  return 0; } 

/* https://github.com/torvalds/linux/blob/adc218676eef25575469234709c2d87185ca223a/arch/loongarch/kernel/ptrace.c#L1077 */ void user_enable_single_step(struct task_struct *task) { struct thread_info *ti = task_thread_info(task);      /* Выставляем точку останова */ set_single_step(task, task_pt_regs(task)->csr_era);     /* Запоминаем адрес */ task->thread.single_step = task_pt_regs(task)->csr_era; set_ti_thread_flag(ti, TIF_SINGLESTEP); }  /* https://github.com/torvalds/linux/blob/adc218676eef25575469234709c2d87185ca223a/arch/loongarch/kernel/ptrace.c#L1035 */ static int set_single_step(struct task_struct *tsk, unsigned long addr) { struct perf_event *bp; struct perf_event_attr attr; struct arch_hw_breakpoint *info; struct thread_struct *thread = &tsk->thread;  bp = thread->hbp_break[0]; if (!bp) { ptrace_breakpoint_init(&attr);  attr.bp_addr = addr; attr.bp_len = HW_BREAKPOINT_LEN_8; attr.bp_type = HW_BREAKPOINT_X;  bp = register_user_hw_breakpoint(&attr, ptrace_triggered,  NULL, tsk); if (IS_ERR(bp)) return PTR_ERR(bp);  thread->hbp_break[0] = bp; } else { int err;  attr = bp->attr; attr.bp_addr = addr;  /* Reenable breakpoint */ attr.disabled = false; err = modify_user_hw_breakpoint(bp, &attr); if (unlikely(err)) return err;  csr_write64(attr.bp_addr, LOONGARCH_CSR_IB0ADDR); } info = counter_arch_bp(bp); info->mask = TASK_SIZE - 1;  return 0; } 

/* https://github.com/torvalds/linux/blob/adc218676eef25575469234709c2d87185ca223a/arch/loongarch/kernel/traps.c#L787 */ asmlinkage void noinstr do_watch(struct pt_regs *regs) { irqentry_state_t state = irqentry_enter(regs);  if (kgdb_breakpoint_handler(regs)) goto out;  if (test_tsk_thread_flag(current, TIF_SINGLESTEP)) { int llbit = (csr_read32(LOONGARCH_CSR_LLBCTL) & 0x1); unsigned long pc = instruction_pointer(regs); union loongarch_instruction *ip = (union loongarch_instruction *)pc;  if (llbit) { /*  * When the ll-sc combo is encountered, it is regarded as an single  * instruction. So don't clear llbit and reset CSR.FWPS.Skip until  * the llsc execution is completed.  */ csr_write32(CSR_FWPC_SKIP, LOONGARCH_CSR_FWPS); csr_write32(CSR_LLBCTL_KLO, LOONGARCH_CSR_LLBCTL); goto out; }  if (pc == current->thread.single_step) { /*  * Certain insns are occasionally not skipped when CSR.FWPS.Skip is  * set, such as fld.d/fst.d. So singlestep needs to compare whether  * the csr_era is equal to the value of singlestep which last time set.  */ if (!is_self_loop_ins(ip, regs)) { /*  * Check if the given instruction the target pc is equal to the  * current pc, If yes, then we should not set the CSR.FWPS.SKIP  * bit to break the original instruction stream.  */ csr_write32(CSR_FWPC_SKIP, LOONGARCH_CSR_FWPS); goto out; } } } else { breakpoint_handler(regs); watchpoint_handler(regs); }  force_sig(SIGTRAP); out: irqentry_exit(regs, state); }