[all-commits] [llvm/llvm-project] 94d9f1: [lldb] Batch breakpoint step-over for threads stop...

[barsolo2000 via All-commits]

  Branch: refs/heads/main
  Home:   https://github.com/llvm/llvm-project
  Commit: 94d9f1b3cbb02700d9cd3339c1dbf44c0d13b550
      https://github.com/llvm/llvm-project/commit/94d9f1b3cbb02700d9cd3339c1dbf44c0d13b550
  Author: barsolo2000 <barsolo at meta.com>
  Date:   2026-02-25 (Wed, 25 Feb 2026)

  Changed paths:
    M lldb/include/lldb/Target/ThreadList.h
    M lldb/include/lldb/Target/ThreadPlanStepOverBreakpoint.h
    M lldb/source/Target/ThreadList.cpp
    M lldb/source/Target/ThreadPlanStepOverBreakpoint.cpp
    A lldb/test/API/functionalities/gdb_remote_client/TestBatchedBreakpointStepOver.py
    A lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentBatchedBreakpointStepOver.py

  Log Message:
  -----------
  [lldb] Batch breakpoint step-over for threads stopped at the same site (re-land) (#182944)

Re-land https://github.com/llvm/llvm-project/pull/180101 since it was
reverted here https://github.com/llvm/llvm-project/pull/182431 because
of a flaky test. This PR include the modified test that should pass from
https://github.com/llvm/llvm-project/pull/182415 :

When multiple threads are stopped at the same breakpoint, LLDB currently
steps each thread over the breakpoint one at a time. Each step requires
disabling the breakpoint, single-stepping one thread, and re-enabling
it, resulting in N disable/enable cycles and N individual vCont packets
for N threads. This is a common scenario for hot breakpoints in
multithreaded programs and scales poorly.

This patch batches the step-over so that all threads at the same
breakpoint site are stepped together in a single vCont packet, with the
breakpoint disabled once at the start and re-enabled once after the last
thread finishes.

At the top of WillResume, any leftover StepOverBreakpoint plans from a
previous cycle are popped with their re-enable side effect suppressed
via SetReenabledBreakpointSite, giving a clean slate.
SetupToStepOverBreakpointIfNeeded then creates fresh plans for all
threads that still need to step over a breakpoint, and these are grouped
by breakpoint address.

For groups with multiple threads, each plan is set to defer its
re-enable through SetDeferReenableBreakpointSite. Instead of re-enabling
the breakpoint directly when a plan completes, it calls
ThreadFinishedSteppingOverBreakpoint, which decrements a per-address
tracking count. The breakpoint is only re-enabled when the count reaches
zero.

All threads in the largest group are resumed together in a single
batched vCont packet. If some threads don't complete their step in one
cycle, the pop-and-recreate logic naturally re-batches the remaining
threads on the next WillResume call.

For 10 threads at the same breakpoint, this reduces the operation from
10 z0/Z0 pairs and 10 vCont packets to 1 z0 + 1 Z0 and a few
progressively smaller batched vCont packets.

Co-authored-by: Bar Soloveychik <barsolo at fb.com>



To unsubscribe from these emails, change your notification settings at https://github.com/llvm/llvm-project/settings/notifications