/* 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_BRK64	UL(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_PROGTRAP		0x00020000 /* 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_TRAP		SRR1_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_GETHWDBGINFO	0x89
#define PPC_PTRACE_SETHWDEBUG	0x88
#define PPC_PTRACE_DELHWDEBUG	0x87

/* 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);
}