Send reverse request from parent DAP instance and report errors

Author: qxy11

lldb/include/lldb/API/SBTarget.h

@@ -65,6 +65,10 @@ class LLDB_API SBTarget {
 
   static lldb::SBTarget GetTargetFromEvent(const lldb::SBEvent &event);
 
+  /// For eBroadcastBitNewTargetCreated events, returns the newly created target.
+  /// For other event types, returns an invalid SBTarget.
+  static lldb::SBTarget GetCreatedTargetFromEvent(const lldb::SBEvent &event);
+
   static uint32_t GetNumModulesFromEvent(const lldb::SBEvent &event);
 
   static lldb::SBModule GetModuleAtIndexFromEvent(const uint32_t idx,

lldb/include/lldb/Target/Target.h

@@ -557,6 +557,12 @@ class Target : public std::enable_shared_from_this<Target>,
     TargetEventData(const lldb::TargetSP &target_sp,
                     const ModuleList &module_list);
 
+    // Constructor for eBroadcastBitNewTargetCreated events. For this event type:
+    // - target_sp is the parent target (the subject/broadcaster of the event)
+    // - created_target_sp is the newly created target
+    TargetEventData(const lldb::TargetSP &target_sp,
+                    const lldb::TargetSP &created_target_sp);
+
     ~TargetEventData() override;
 
     static llvm::StringRef GetFlavorString();
@@ -571,14 +577,21 @@ class Target : public std::enable_shared_from_this<Target>,
 
     static lldb::TargetSP GetTargetFromEvent(const Event *event_ptr);
 
+    // For eBroadcastBitNewTargetCreated events, returns the newly created target.
+    // For other event types, returns an invalid target.
+    static lldb::TargetSP GetCreatedTargetFromEvent(const Event *event_ptr);
+
     static ModuleList GetModuleListFromEvent(const Event *event_ptr);
 
     const lldb::TargetSP &GetTarget() const { return m_target_sp; }
 
+    const lldb::TargetSP &GetCreatedTarget() const { return m_created_target_sp; }
+
     const ModuleList &GetModuleList() const { return m_module_list; }
 
   private:
     lldb::TargetSP m_target_sp;
+    lldb::TargetSP m_created_target_sp;
     ModuleList m_module_list;
 
     TargetEventData(const TargetEventData &) = delete;

lldb/source/API/SBTarget.cpp

@@ -128,6 +128,12 @@ SBTarget SBTarget::GetTargetFromEvent(const SBEvent &event) {
   return Target::TargetEventData::GetTargetFromEvent(event.get());
 }
 
+SBTarget SBTarget::GetCreatedTargetFromEvent(const SBEvent &event) {
+  LLDB_INSTRUMENT_VA(event);
+
+  return Target::TargetEventData::GetCreatedTargetFromEvent(event.get());
+}
+
 uint32_t SBTarget::GetNumModulesFromEvent(const SBEvent &event) {
   LLDB_INSTRUMENT_VA(event);
 

lldb/source/Target/Target.cpp

@@ -5204,6 +5204,11 @@ Target::TargetEventData::TargetEventData(const lldb::TargetSP &target_sp,
                                          const ModuleList &module_list)
     : EventData(), m_target_sp(target_sp), m_module_list(module_list) {}
 
+Target::TargetEventData::TargetEventData(const lldb::TargetSP &target_sp,
+                                         const lldb::TargetSP &created_target_sp)
+    : EventData(), m_target_sp(target_sp), m_created_target_sp(created_target_sp),
+      m_module_list() {}
+
 Target::TargetEventData::~TargetEventData() = default;
 
 llvm::StringRef Target::TargetEventData::GetFlavorString() {
@@ -5238,6 +5243,15 @@ TargetSP Target::TargetEventData::GetTargetFromEvent(const Event *event_ptr) {
   return target_sp;
 }
 
+TargetSP
+Target::TargetEventData::GetCreatedTargetFromEvent(const Event *event_ptr) {
+  TargetSP created_target_sp;
+  const TargetEventData *event_data = GetEventDataFromEvent(event_ptr);
+  if (event_data)
+    created_target_sp = event_data->m_created_target_sp;
+  return created_target_sp;
+}
+
 ModuleList
 Target::TargetEventData::GetModuleListFromEvent(const Event *event_ptr) {
   ModuleList module_list;

lldb/tools/lldb-dap/EventHelper.cpp

@@ -468,35 +468,50 @@ void EventThread(lldb::SBDebugger debugger, lldb::SBBroadcaster broadcaster,
             }
           }
         } else if (event_mask & lldb::SBTarget::eBroadcastBitNewTargetCreated) {
-          auto target = lldb::SBTarget::GetTargetFromEvent(event);
+          // For NewTargetCreated events, GetTargetFromEvent returns the parent
+          // target (the subject of the event), and GetCreatedTargetFromEvent
+          // returns the newly created target.
+          lldb::SBTarget target =
+              lldb::SBTarget::GetTargetFromEvent(event);
+          lldb::SBTarget created_target =
+              lldb::SBTarget::GetCreatedTargetFromEvent(event);
+
+          if (!target.IsValid() || !created_target.IsValid()) {
+            DAP_LOG(log,
+                    "Received NewTargetCreated event but parent or "
+                    "created target is invalid");
+            continue;
+          }
 
-          // Find the DAP instance that owns this target
+          // Find the DAP instance that spawned this target by looking up the
+          // parent target.
           DAP *dap_instance = DAPSessionManager::FindDAP(target);
-          // If we don't have a dap_instance (target wasn't found), get any
-          // active instance
           if (!dap_instance) {
-            std::vector<DAP *> active_instances =
-                DAPSessionManager::GetInstance().GetActiveSessions();
-            if (!active_instances.empty())
-              dap_instance = active_instances[0];
+            DAP_LOG(log,
+                    "Received NewTargetCreated event but could not find "
+                    "DAP instance for target");
+            continue;
           }
 
-          if (dap_instance) {
-            // Send a startDebugging reverse request with the debugger and target
-            // IDs. The new DAP instance will use these IDs to find the existing
-            // debugger and target via FindDebuggerWithID and
-            // FindTargetByGloballyUniqueID.
-            llvm::json::Object configuration{
-                {"type", "lldb"},
-                {"debuggerId", target.GetDebugger().GetID()},
-                {"targetId", target.GetGloballyUniqueID()},
-                {"name", target.GetTargetSessionName()}};
-
-            dap_instance->SendReverseRequest<LogFailureResponseHandler>(
-                "startDebugging", llvm::json::Object{{"request", "attach"},
-                                                     {"configuration",
-                                                      std::move(configuration)}});
-          }
+          // Send a startDebugging reverse request with the debugger and target
+          // IDs. The new DAP instance will use these IDs to find the existing
+          // debugger and target via FindDebuggerWithID and
+          // FindTargetByGloballyUniqueID.
+          llvm::json::Object configuration;
+          configuration.try_emplace("type", "lldb");
+          configuration.try_emplace("debuggerId",
+                                    created_target.GetDebugger().GetID());
+          configuration.try_emplace("targetId",
+                                    created_target.GetGloballyUniqueID());
+          configuration.try_emplace("name",
+                                    created_target.GetTargetSessionName());
+
+          llvm::json::Object request;
+          request.try_emplace("request", "attach");
+          request.try_emplace("configuration", std::move(configuration));
+
+          dap_instance->SendReverseRequest<LogFailureResponseHandler>(
+              "startDebugging", std::move(request));
         }
       } else if (lldb::SBBreakpoint::EventIsBreakpointEvent(event)) {
         lldb::SBBreakpoint bp =