Integrate dual connection w/ LLDB-DAP using shared event thread

lldb/include/lldb/API/SBTarget.h

@@ -44,6 +44,7 @@ class LLDB_API SBTarget {
     eBroadcastBitWatchpointChanged = (1 << 3),
     eBroadcastBitSymbolsLoaded = (1 << 4),
     eBroadcastBitSymbolsChanged = (1 << 5),
+    eBroadcastBitNewTargetSpawned = (1 << 6),
   };
 
   // Constructors

lldb/include/lldb/Target/Target.h

@@ -536,6 +536,7 @@ class Target : public std::enable_shared_from_this<Target>,
     eBroadcastBitWatchpointChanged = (1 << 3),
     eBroadcastBitSymbolsLoaded = (1 << 4),
     eBroadcastBitSymbolsChanged = (1 << 5),
+    eBroadcastBitNewTargetSpawned = (1 << 6),
   };
 
   // These two functions fill out the Broadcaster interface:

lldb/packages/Python/lldbsuite/test/tools/lldb-dap/dap_server.py

@@ -315,8 +315,28 @@ def _handle_recv_packet(self, packet: Optional[ProtocolMessage]) -> bool:
         elif packet_type == "response":
             if packet["command"] == "disconnect":
                 keepGoing = False
+        elif packet_type == "request":
+            # This is a reverse request automatically spawned from LLDB (eg. for GPU targets)
+            command = packet.get("command", "unknown")
+            self.reverse_requests.append(packet)
+            if command == "startDebugging":
+                self._handle_startDebugging_request(packet)
+            else:
+                desc = f"unhandled automatic reverse request of type {command}"
+                raise ValueError(desc)
+
         self._enqueue_recv_packet(packet)
         return keepGoing
+
+    def _handle_startDebugging_request(self, packet):
+        response = {
+            "type": "response",
+            "request_seq": packet.get("seq", 0),
+            "success": True,
+            "command": "startDebugging",
+            "body": {}
+        }
+        self.send_packet(response, set_sequence=True)
 
     def _process_continued(self, all_threads_continued: bool):
         self.frame_scopes = {}
@@ -670,6 +690,7 @@ def request_attach(
         sourceMap: Optional[Union[list[tuple[str, str]], dict[str, str]]] = None,
         gdbRemotePort: Optional[int] = None,
         gdbRemoteHostname: Optional[str] = None,
+        targetIdx: Optional[int] = None,
     ):
         args_dict = {}
         if pid is not None:
@@ -703,6 +724,8 @@ def request_attach(
             args_dict["gdb-remote-port"] = gdbRemotePort
         if gdbRemoteHostname is not None:
             args_dict["gdb-remote-hostname"] = gdbRemoteHostname
+        if targetIdx is not None:
+            args_dict["targetIdx"] = targetIdx
         command_dict = {"command": "attach", "type": "request", "arguments": args_dict}
         return self.send_recv(command_dict)
 
@@ -1333,6 +1356,8 @@ def __init__(
     ):
         self.process = None
         self.connection = None
+        self.child_dap_sessions: list["DebugAdapterServer"] = []  # Track child sessions for cleanup
+
         if executable is not None:
             process, connection = DebugAdapterServer.launch(
                 executable=executable, connection=connection, env=env, log_file=log_file
@@ -1414,6 +1439,65 @@ def get_pid(self) -> int:
         if self.process:
             return self.process.pid
         return -1
+
+    def get_child_sessions(self) -> list["DebugAdapterServer"]:
+        return self.child_dap_sessions
+
+    def _handle_startDebugging_request(self, packet):
+        """Launch a new DebugAdapterServer with attach config parameters from the packet"""
+        try:
+            # Extract arguments from the packet
+            arguments = packet.get('arguments', {})
+            request_type = arguments.get('request', 'attach')  # 'attach' or 'launch'
+            configuration = arguments.get('configuration', {})
+
+            # Create a new DAP session that launches its own lldb-dap process
+            child_dap = DebugAdapterServer(
+                connection=self.connection,
+                log_file=self.log_file
+            )
+
+            # Track the child session for proper cleanup
+            self.child_dap_sessions.append(child_dap)
+
+            # Initialize the child DAP session
+            child_dap.request_initialize()
+
+            # Configure the child session based on the request type and configuration
+            if request_type == 'attach':
+                # Extract attach-specific parameters
+                attach_commands = configuration.get('attachCommands', [])
+                target_idx = configuration.get('targetIdx', None)
+
+                # Send attach request to the child DAP
+                child_dap.request_attach(
+                    attachCommands=attach_commands,
+                    targetIdx=target_idx,
+                )
+            else:
+                raise ValueError(f"Unsupported startDebugging request type: {request_type}")
+
+            # Send success response
+            response = {
+                "type": "response",
+                "request_seq": packet.get("seq", 0),
+                "success": True,
+                "command": "startDebugging",
+                "body": {}
+            }
+
+        except Exception as e:
+            # Send error response
+            response = {
+                "type": "response", 
+                "request_seq": packet.get("seq", 0),
+                "success": False,
+                "command": "startDebugging",
+                "message": f"Failed to start debugging: {str(e)}",
+                "body": {}
+            }
+
+        self.send_packet(response, set_sequence=True)
 
     def terminate(self):
         try:

lldb/packages/Python/lldbsuite/test/tools/lldb-dap/lldbdap_testcase.py

@@ -35,6 +35,119 @@ def create_debug_adapter(
             env=lldbDAPEnv,
         )
 
+    def _get_dap_server(self, child_session_index: Optional[int] = None) -> dap_server.DebugAdapterServer:
+        """Get a specific DAP server instance.
+
+        Args:
+            child_session_index: Index of child session, or None for main session
+
+        Returns:
+            The requested DAP server instance
+        """
+        if child_session_index is None:
+            return self.dap_server
+        else:
+            child_sessions = self.dap_server.get_child_sessions()
+            if child_session_index >= len(child_sessions):
+                raise IndexError(f"Child session index {child_session_index} out of range. Found {len(child_sessions)} child sessions.")
+            return child_sessions[child_session_index]
+
+    def _set_source_breakpoints_impl(self, dap_server_instance, source_path, lines, data=None, wait_for_resolve=True):
+        """Implementation for setting source breakpoints on any DAP server"""
+        response = dap_server_instance.request_setBreakpoints(Source(source_path), lines, data)
+        if response is None or not response["success"]:
+            return []
+        breakpoints = response["body"]["breakpoints"]
+        breakpoint_ids = []
+        for breakpoint in breakpoints:
+            breakpoint_ids.append("%i" % (breakpoint["id"]))
+        if wait_for_resolve:
+            self._wait_for_breakpoints_to_resolve_impl(dap_server_instance, breakpoint_ids)
+        return breakpoint_ids
+
+    def _wait_for_breakpoints_to_resolve_impl(self, dap_server_instance, breakpoint_ids, timeout=None):
+        """Implementation for waiting for breakpoints to resolve on any DAP server"""
+        if timeout is None:
+            timeout = self.DEFAULT_TIMEOUT
+        unresolved_breakpoints = dap_server_instance.wait_for_breakpoints_to_be_verified(breakpoint_ids, timeout)
+        self.assertEqual(
+            len(unresolved_breakpoints),
+            0,
+            f"Expected to resolve all breakpoints. Unresolved breakpoint ids: {unresolved_breakpoints}",
+        )
+
+    def _verify_breakpoint_hit_impl(self, dap_server_instance, breakpoint_ids, timeout=None):
+        """Implementation for verifying breakpoint hit on any DAP server"""
+        if timeout is None:
+            timeout = self.DEFAULT_TIMEOUT
+        stopped_events = dap_server_instance.wait_for_stopped(timeout)
+        for stopped_event in stopped_events:
+            if "body" in stopped_event:
+                body = stopped_event["body"]
+                if "reason" not in body:
+                    continue
+                if (
+                    body["reason"] != "breakpoint"
+                    and body["reason"] != "instruction breakpoint"
+                ):
+                    continue
+                if "description" not in body:
+                    continue
+                # Descriptions for breakpoints will be in the form
+                # "breakpoint 1.1", so look for any description that matches
+                # ("breakpoint 1.") in the description field as verification
+                # that one of the breakpoint locations was hit. DAP doesn't
+                # allow breakpoints to have multiple locations, but LLDB does.
+                # So when looking at the description we just want to make sure
+                # the right breakpoint matches and not worry about the actual
+                # location.
+                description = body["description"]
+                for breakpoint_id in breakpoint_ids:
+                    match_desc = f"breakpoint {breakpoint_id}."
+                    if match_desc in description:
+                        return
+        self.assertTrue(False, f"breakpoint not hit, stopped_events={stopped_events}")
+
+    def _do_continue_impl(self, dap_server_instance):
+        """Implementation for continuing execution on any DAP server"""
+        resp = dap_server_instance.request_continue()
+        self.assertTrue(resp["success"], f"continue request failed: {resp}")
+
+    # Multi-session methods for operating on specific sessions without switching context
+    def set_source_breakpoints_on(self, child_session_index: Optional[int], source_path, lines, data=None, wait_for_resolve=True):
+        """Set source breakpoints on a specific DAP session without switching the active session."""
+        return self._set_source_breakpoints_impl(
+            self._get_dap_server(child_session_index), source_path, lines, data, wait_for_resolve
+        )
+
+    def verify_breakpoint_hit_on(self, child_session_index: Optional[int], breakpoint_ids: list[str], timeout=DEFAULT_TIMEOUT):
+        """Verify breakpoint hit on a specific DAP session without switching the active session."""
+        return self._verify_breakpoint_hit_impl(
+            self._get_dap_server(child_session_index), breakpoint_ids, timeout
+        )
+
+    def do_continue_on(self, child_session_index: Optional[int]):
+        """Continue execution on a specific DAP session without switching the active session."""
+        return self._do_continue_impl(self._get_dap_server(child_session_index))
+
+    def start_server(self, connection):
+        """
+        Start an lldb-dap server process listening on the specified connection.
+        """
+        log_file_path = self.getBuildArtifact("dap.txt")
+        (process, connection) = dap_server.DebugAdapterServer.launch(
+            executable=self.lldbDAPExec,
+            connection=connection,
+            log_file=log_file_path
+        )
+
+        def cleanup():
+            process.terminate()
+
+        self.addTearDownHook(cleanup)
+
+        return (process, connection)
+
     def build_and_create_debug_adapter(
         self,
         lldbDAPEnv: Optional[dict[str, str]] = None,
@@ -59,18 +172,9 @@ def set_source_breakpoints(
         Each object in data is 1:1 mapping with the entry in lines.
         It contains optional location/hitCondition/logMessage parameters.
         """
-        response = self.dap_server.request_setBreakpoints(
-            Source(source_path), lines, data
+        return self._set_source_breakpoints_impl(
+            self.dap_server, source_path, lines, data, wait_for_resolve
         )
-        if response is None or not response["success"]:
-            return []
-        breakpoints = response["body"]["breakpoints"]
-        breakpoint_ids = []
-        for breakpoint in breakpoints:
-            breakpoint_ids.append("%i" % (breakpoint["id"]))
-        if wait_for_resolve:
-            self.wait_for_breakpoints_to_resolve(breakpoint_ids)
-        return breakpoint_ids
 
     def set_source_breakpoints_assembly(
         self, source_reference, lines, data=None, wait_for_resolve=True
@@ -113,13 +217,8 @@ def set_function_breakpoints(
     def wait_for_breakpoints_to_resolve(
         self, breakpoint_ids: list[str], timeout: Optional[float] = DEFAULT_TIMEOUT
     ):
-        unresolved_breakpoints = self.dap_server.wait_for_breakpoints_to_be_verified(
-            breakpoint_ids, timeout
-        )
-        self.assertEqual(
-            len(unresolved_breakpoints),
-            0,
-            f"Expected to resolve all breakpoints. Unresolved breakpoint ids: {unresolved_breakpoints}",
+        return self._wait_for_breakpoints_to_resolve_impl(
+            self.dap_server, breakpoint_ids, timeout
         )
 
     def waitUntil(self, condition_callback):
@@ -145,33 +244,7 @@ def verify_breakpoint_hit(self, breakpoint_ids, timeout=DEFAULT_TIMEOUT):
         "breakpoint_ids" should be a list of breakpoint ID strings
         (["1", "2"]). The return value from self.set_source_breakpoints()
         or self.set_function_breakpoints() can be passed to this function"""
-        stopped_events = self.dap_server.wait_for_stopped(timeout)
-        for stopped_event in stopped_events:
-            if "body" in stopped_event:
-                body = stopped_event["body"]
-                if "reason" not in body:
-                    continue
-                if (
-                    body["reason"] != "breakpoint"
-                    and body["reason"] != "instruction breakpoint"
-                ):
-                    continue
-                if "description" not in body:
-                    continue
-                # Descriptions for breakpoints will be in the form
-                # "breakpoint 1.1", so look for any description that matches
-                # ("breakpoint 1.") in the description field as verification
-                # that one of the breakpoint locations was hit. DAP doesn't
-                # allow breakpoints to have multiple locations, but LLDB does.
-                # So when looking at the description we just want to make sure
-                # the right breakpoint matches and not worry about the actual
-                # location.
-                description = body["description"]
-                for breakpoint_id in breakpoint_ids:
-                    match_desc = f"breakpoint {breakpoint_id}."
-                    if match_desc in description:
-                        return
-        self.assertTrue(False, f"breakpoint not hit, stopped_events={stopped_events}")
+        self._verify_breakpoint_hit_impl(self.dap_server, breakpoint_ids, timeout)
 
     def verify_all_breakpoints_hit(self, breakpoint_ids, timeout=DEFAULT_TIMEOUT):
         """Wait for the process we are debugging to stop, and verify we hit
@@ -384,8 +457,7 @@ def stepOut(self, threadId=None, waitForStop=True, timeout=DEFAULT_TIMEOUT):
         return None
 
     def do_continue(self):  # `continue` is a keyword.
-        resp = self.dap_server.request_continue()
-        self.assertTrue(resp["success"], f"continue request failed: {resp}")
+        self._do_continue_impl(self.dap_server)
 
     def continue_to_next_stop(self, timeout=DEFAULT_TIMEOUT):
         self.do_continue()
@@ -478,7 +550,6 @@ def launch(
         **kwargs,
     ):
         """Sending launch request to dap"""
-
         # Make sure we disconnect and terminate the DAP debug adapter,
         # if we throw an exception during the test case
         def cleanup():

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

@@ -1025,6 +1025,10 @@ Status ProcessGDBRemote::HandleConnectionRequest(const GPUActions &gpu_action) {
                                  process_sp->GetTarget().shared_from_this());
   LLDB_LOG(log, "ProcessGDBRemote::HandleConnectionRequest(): successfully "
                 "created process!!!");
+  auto event_sp =
+      std::make_shared<Event>(Target::eBroadcastBitNewTargetSpawned,
+                              new Target::TargetEventData(gpu_target_sp));
+  GetTarget().BroadcastEvent(event_sp);
   return Status();
 }
 

lldb/source/Target/Target.cpp

@@ -190,6 +190,7 @@ Target::Target(Debugger &debugger, const ArchSpec &target_arch,
   SetEventName(eBroadcastBitModulesUnloaded, "modules-unloaded");
   SetEventName(eBroadcastBitWatchpointChanged, "watchpoint-changed");
   SetEventName(eBroadcastBitSymbolsLoaded, "symbols-loaded");
+  SetEventName(eBroadcastBitNewTargetSpawned, "new-target-spawned");
 
   CheckInWithManager();
 

lldb/test/API/tools/lldb-dap/gpu/Makefile

@@ -0,0 +1,3 @@
+HIP_SOURCES := hello_world.hip
+
+include Makefile.rules