Unique target ids + dap_session_name -> session_name

Author: qxy11

lldb/include/lldb/API/SBTarget.h

@@ -70,7 +70,7 @@ class LLDB_API SBTarget {
   static lldb::SBModule GetModuleAtIndexFromEvent(const uint32_t idx,
                                                   const lldb::SBEvent &event);
 
-  static const char *GetDAPSessionNameFromEvent(const SBEvent &event);
+  static const char *GetSessionNameFromEvent(const SBEvent &event);
 
   static const char *GetBroadcasterClassName();
 

lldb/include/lldb/Target/Target.h

@@ -558,12 +558,10 @@ class Target : public std::enable_shared_from_this<Target>,
     TargetEventData(const lldb::TargetSP &target_sp,
                     const ModuleList &module_list);
 
-    TargetEventData(const lldb::TargetSP &target_sp,
-                    std::string dap_session_name);
+    TargetEventData(const lldb::TargetSP &target_sp, std::string session_name);
 
     TargetEventData(const lldb::TargetSP &target_sp,
-                    const ModuleList &module_list,
-                    std::string dap_session_name);
+                    const ModuleList &module_list, std::string session_name);
 
     ~TargetEventData() override;
 
@@ -573,7 +571,7 @@ class Target : public std::enable_shared_from_this<Target>,
       return TargetEventData::GetFlavorString();
     }
 
-    static llvm::StringRef GetDAPSessionNameFromEvent(const Event *event_ptr);
+    static llvm::StringRef GetSessionNameFromEvent(const Event *event_ptr);
 
     void Dump(Stream *s) const override;
 
@@ -590,7 +588,7 @@ class Target : public std::enable_shared_from_this<Target>,
   private:
     lldb::TargetSP m_target_sp;
     ModuleList m_module_list;
-    std::string m_dap_session_name = "";
+    std::string m_session_name = "";
 
     TargetEventData(const TargetEventData &) = delete;
     const TargetEventData &operator=(const TargetEventData &) = delete;
@@ -612,6 +610,12 @@ class Target : public std::enable_shared_from_this<Target>,
 
   bool IsDummyTarget() const { return m_is_dummy_target; }
 
+  /// Get the unique ID for this target.
+  ///
+  /// \return
+  ///     The unique ID for this target, or 0 if no ID has been assigned.
+  uint32_t GetUniqueID() const { return m_target_unique_id; }
+
   const std::string &GetLabel() const { return m_label; }
 
   /// Set a label for a target.
@@ -1700,6 +1704,7 @@ class Target : public std::enable_shared_from_this<Target>,
   bool m_suppress_stop_hooks; /// Used to not run stop hooks for expressions
   bool m_is_dummy_target;
   unsigned m_next_persistent_variable_index = 0;
+  uint32_t m_target_unique_id = 0; /// The unique ID assigned to this target
   /// An optional \a lldb_private::Trace object containing processor trace
   /// information of this target.
   lldb::TraceSP m_trace_sp;

lldb/include/lldb/Utility/GPUGDBRemotePackets.h

@@ -228,7 +228,7 @@ struct GPUActions {
   /// The name of the plugin.
   std::string plugin_name;
   /// The name to give a DAP session
-  std::string dap_session_name;
+  std::string session_name;
   /// Unique identifier for every GPU action.
   uint32_t identifier = 0;
   /// The stop ID in the process that this action is associated with. If the

lldb/source/API/SBTarget.cpp

@@ -145,11 +145,11 @@ SBModule SBTarget::GetModuleAtIndexFromEvent(const uint32_t idx,
   return SBModule(module_list.GetModuleAtIndex(idx));
 }
 
-const char *SBTarget::GetDAPSessionNameFromEvent(const SBEvent &event) {
+const char *SBTarget::GetSessionNameFromEvent(const SBEvent &event) {
   LLDB_INSTRUMENT_VA(event);
 
   return ConstString(
-             Target::TargetEventData::GetDAPSessionNameFromEvent(event.get()))
+             Target::TargetEventData::GetSessionNameFromEvent(event.get()))
       .AsCString();
 }
 

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

@@ -1115,7 +1115,7 @@ Status ProcessGDBRemote::HandleConnectionRequest(const GPUActions &gpu_action) {
                 "created process!!!");
   auto event_sp = std::make_shared<Event>(
       Target::eBroadcastBitNewTargetCreated,
-      new Target::TargetEventData(gpu_target_sp, gpu_action.dap_session_name));
+      new Target::TargetEventData(gpu_target_sp, gpu_action.session_name));
   GetTarget().BroadcastEvent(event_sp);
   return Status();
 }

lldb/source/Target/Target.cpp

@@ -5153,14 +5153,14 @@ Target::TargetEventData::TargetEventData(const lldb::TargetSP &target_sp,
     : TargetEventData(target_sp, module_list, "") {}
 
 Target::TargetEventData::TargetEventData(const lldb::TargetSP &target_sp,
-                                         std::string dap_session_name)
-    : TargetEventData(target_sp, ModuleList(), std::move(dap_session_name)) {}
+                                         std::string session_name)
+    : TargetEventData(target_sp, ModuleList(), std::move(session_name)) {}
 
 Target::TargetEventData::TargetEventData(const lldb::TargetSP &target_sp,
                                          const ModuleList &module_list,
-                                         std::string dap_session_name)
+                                         std::string session_name)
     : EventData(), m_target_sp(target_sp), m_module_list(module_list),
-      m_dap_session_name(std::move(dap_session_name)) {}
+      m_session_name(std::move(session_name)) {}
 
 Target::TargetEventData::~TargetEventData() = default;
 
@@ -5197,10 +5197,10 @@ TargetSP Target::TargetEventData::GetTargetFromEvent(const Event *event_ptr) {
 }
 
 llvm::StringRef
-Target::TargetEventData::GetDAPSessionNameFromEvent(const Event *event_ptr) {
+Target::TargetEventData::GetSessionNameFromEvent(const Event *event_ptr) {
   const TargetEventData *event_data = GetEventDataFromEvent(event_ptr);
   if (event_data)
-    return event_data->m_dap_session_name;
+    return event_data->m_session_name;
   return llvm::StringRef();
 }
 

lldb/source/Target/TargetList.cpp

@@ -176,7 +176,7 @@ Status TargetList::CreateTargetInternal(
         module_spec.GetArchitecture() = arch;
         if (module_specs.FindMatchingModuleSpec(module_spec,
                                                 matching_module_spec))
-            update_platform_arch(matching_module_spec.GetArchitecture());
+          update_platform_arch(matching_module_spec.GetArchitecture());
       } else {
         // Fat binary. No architecture specified, check if there is
         // only one platform for all of the architectures.
@@ -256,6 +256,9 @@ Status TargetList::CreateTargetInternal(Debugger &debugger,
   Status error;
   const bool is_dummy_target = false;
 
+  // Global static counter for assigning unique IDs to targets
+  static uint32_t g_target_unique_id = 0;
+
   ArchSpec arch(specified_arch);
 
   if (arch.IsValid()) {
@@ -294,7 +297,7 @@ Status TargetList::CreateTargetInternal(Debugger &debugger,
 
     if (file.IsRelative() && !user_exe_path.empty()) {
       llvm::SmallString<64> cwd;
-      if (! llvm::sys::fs::current_path(cwd)) {
+      if (!llvm::sys::fs::current_path(cwd)) {
         FileSpec cwd_file(cwd.c_str());
         cwd_file.AppendPathComponent(file);
         if (FileSystem::Instance().Exists(cwd_file))
@@ -344,6 +347,8 @@ Status TargetList::CreateTargetInternal(Debugger &debugger,
   if (!target_sp)
     return error;
 
+  target_sp->m_target_unique_id = ++g_target_unique_id;
+
   // Set argv0 with what the user typed, unless the user specified a
   // directory. If the user specified a directory, then it is probably a
   // bundle that was resolved and we need to use the resolved bundle path
@@ -431,8 +436,7 @@ TargetSP TargetList::FindTargetWithProcess(Process *process) const {
 TargetSP TargetList::FindTargetWithUniqueID(uint32_t id) const {
   std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
   auto it = llvm::find_if(m_target_list, [id](const TargetSP &item) {
-    auto *process_ptr = item->GetProcessSP().get();
-    return process_ptr && (process_ptr->GetUniqueID() == id);
+    return item->GetUniqueID() == id;
   });
 
   if (it != m_target_list.end())
@@ -567,29 +571,27 @@ bool TargetList::AnyTargetContainsModule(Module &module) {
     if (target_sp->GetImages().FindModule(&module))
       return true;
   }
-  for (const auto &target_sp: m_in_process_target_list) {
+  for (const auto &target_sp : m_in_process_target_list) {
     if (target_sp->GetImages().FindModule(&module))
       return true;
   }
   return false;
 }
 
-  void TargetList::RegisterInProcessTarget(TargetSP target_sp) {
-    std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
-    [[maybe_unused]] bool was_added;
-    std::tie(std::ignore, was_added) =
-        m_in_process_target_list.insert(target_sp);
-    assert(was_added && "Target pointer was left in the in-process map");
-  }
-  
-  void TargetList::UnregisterInProcessTarget(TargetSP target_sp) {
-    std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
-    [[maybe_unused]] bool was_present =
-        m_in_process_target_list.erase(target_sp);
-    assert(was_present && "Target pointer being removed was not registered");
-  }
-  
-  bool TargetList::IsTargetInProcess(TargetSP target_sp) {
-    std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
-    return m_in_process_target_list.count(target_sp) == 1; 
-  }
+void TargetList::RegisterInProcessTarget(TargetSP target_sp) {
+  std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
+  [[maybe_unused]] bool was_added;
+  std::tie(std::ignore, was_added) = m_in_process_target_list.insert(target_sp);
+  assert(was_added && "Target pointer was left in the in-process map");
+}
+
+void TargetList::UnregisterInProcessTarget(TargetSP target_sp) {
+  std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
+  [[maybe_unused]] bool was_present = m_in_process_target_list.erase(target_sp);
+  assert(was_present && "Target pointer being removed was not registered");
+}
+
+bool TargetList::IsTargetInProcess(TargetSP target_sp) {
+  std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
+  return m_in_process_target_list.count(target_sp) == 1;
+}

lldb/source/Utility/GPUGDBRemotePackets.cpp

@@ -166,7 +166,7 @@ bool fromJSON(const llvm::json::Value &value, GPUActions &data,
               llvm::json::Path path) {
   ObjectMapper o(value, path);
   return o && o.map("plugin_name", data.plugin_name) &&
-         o.map("dap_session_name", data.dap_session_name) &&
+         o.map("session_name", data.session_name) &&
          o.map("identifier", data.identifier) &&
          o.mapOptional("stop_id", data.stop_id) &&
          o.map("breakpoints", data.breakpoints) &&
@@ -192,6 +192,9 @@ llvm::json::Value toJSON(const GPUActions &data) {
 
   return json::Value(Object{
       {"plugin_name", data.plugin_name},
+      {"session_name", data.session_name},
+      {"identifier", data.identifier},
+      {"stop_id", data.stop_id},
       {"breakpoints", data.breakpoints},
       {"connect_info", data.connect_info},
       {"wait_for_gpu_process_to_stop", data.wait_for_gpu_process_to_stop},

lldb/tools/lldb-dap/DAP.cpp

@@ -1498,7 +1498,7 @@ void DAP::EventThread() {
           attach_config.try_emplace("type", "lldb");
           attach_config.try_emplace("targetId", target_id);
           const char *session_name =
-              lldb::SBTarget::GetDAPSessionNameFromEvent(event);
+              lldb::SBTarget::GetSessionNameFromEvent(event);
           if (session_name && *session_name) {
             attach_config.try_emplace("name", session_name);
           } else {

lldb/tools/lldb-server/Plugins/AMDGPU/LLDBServerPluginAMDGPU.cpp

@@ -164,7 +164,7 @@ LLDBServerPluginAMDGPU::~LLDBServerPluginAMDGPU() { }
 
 llvm::StringRef LLDBServerPluginAMDGPU::GetPluginName() { return "amd-gpu"; }
 
-llvm::StringRef LLDBServerPluginAMDGPU::GetDAPSessionName() {
+llvm::StringRef LLDBServerPluginAMDGPU::GetSessionName() {
   return "AMD GPU Session";
 }
 
@@ -467,7 +467,7 @@ bool LLDBServerPluginAMDGPU::ReadyToSetGpuLoaderBreakpointByAddress() {
 GPUActions LLDBServerPluginAMDGPU::SetConnectionInfo() {
   GPUActions actions = GetNewGPUAction();
   actions.connect_info = CreateConnection();
-  actions.dap_session_name = GetDAPSessionName();
+  actions.session_name = GetSessionName();
   return actions;
 }