AMD fix module path

lldb/include/lldb/Host/common/NativeProcessProtocol.h

@@ -17,6 +17,7 @@
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/Iterable.h"
 #include "lldb/Utility/Status.h"
+#include "lldb/Utility/GPUGDBRemotePackets.h"
 #include "lldb/Utility/TraceGDBRemotePackets.h"
 #include "lldb/Utility/UnimplementedError.h"
 #include "lldb/lldb-private-forward.h"
@@ -179,6 +180,9 @@ class NativeProcessProtocol {
   // Accessors
   lldb::pid_t GetID() const { return m_pid; }
 
+  // Get process info
+  virtual bool GetProcessInfo(ProcessInstanceInfo &proc_info);
+
   lldb::StateType GetState() const;
 
   bool IsRunning() const {
@@ -187,7 +191,9 @@ class NativeProcessProtocol {
 
   bool IsStepping() const { return m_state == lldb::eStateStepping; }
 
-  bool CanResume() const { return m_state == lldb::eStateStopped; }
+  bool IsStopped() const { return m_state == lldb::eStateStopped; }
+
+  bool CanResume() const { return IsStopped(); }
 
   lldb::ByteOrder GetByteOrder() const {
     return GetArchitecture().GetByteOrder();
@@ -252,6 +258,11 @@ class NativeProcessProtocol {
   virtual Status GetFileLoadAddress(const llvm::StringRef &file_name,
                                     lldb::addr_t &load_addr) = 0;
 
+  virtual std::optional<GPUDynamicLoaderResponse> 
+  GetGPUDynamicLoaderLibraryInfos(const GPUDynamicLoaderArgs &args) {
+    return std::nullopt;
+  }
+
   /// Extension flag constants, returned by Manager::GetSupportedExtensions()
   /// and passed to SetEnabledExtension()
   enum class Extension {
@@ -264,8 +275,10 @@ class NativeProcessProtocol {
     memory_tagging = (1u << 6),
     savecore = (1u << 7),
     siginfo_read = (1u << 8),
+    gpu_plugins = (1u << 9),
+    gpu_dyld = (1u << 10),
 
-    LLVM_MARK_AS_BITMASK_ENUM(siginfo_read)
+    LLVM_MARK_AS_BITMASK_ENUM(gpu_dyld)
   };
 
   class Manager {

lldb/include/lldb/Target/DynamicLoader.h

@@ -90,6 +90,17 @@ class DynamicLoader : public PluginInterface {
   /// loader often knows what the program entry point is. So the process and
   /// the dynamic loader can work together to detect this.
   virtual bool ProcessDidExec() { return false; }
+
+  /// A function that allows dynamic loader to handle eStopReasonDynammicLoader
+  /// stop reasons. This is intended for dynamic loaders that aren't able to
+  /// set a breakpoint in the process, but rely on being notified by a driver or
+  /// debug services that shared libraries are available.
+  ///
+  /// \returns True if handled, false otherwise.
+  virtual bool HandleStopReasonDynammicLoader() { 
+    return false;
+  }
+
   /// Get whether the process should stop when images change.
   ///
   /// When images (executables and shared libraries) get loaded or unloaded,

lldb/include/lldb/Target/Process.h

@@ -2311,6 +2311,21 @@ class Process : public std::enable_shared_from_this<Process>,
                        SelectMostRelevant select_most_relevant =
                            DoNoSelectMostRelevantFrame);
 
+  /// Wait for the process to resume.
+  ///
+  /// Given the current ProcessModID that identifies a current state, wait for
+  /// the process to resume. 
+  ///
+  /// \param[in] curr_resume_id
+  ///     The resume ID that identifies the resume ID from a stopped state.
+  ///
+  /// \param[in] timeout_sec
+  ///     The maximum time in seconds to wait for the process to transition to
+  ///     the eStateRunning state. If no timeout is supplied, block and wait
+  ///     indefinitely.
+  Status WaitForNextResume(const uint32_t curr_resume_id, 
+                           std::optional<uint32_t> timeout_sec);
+
   uint32_t GetIOHandlerID() const { return m_iohandler_sync.GetValue(); }
 
   /// Waits for the process state to be running within a given msec timeout.

lldb/include/lldb/Target/StopInfo.h

@@ -174,6 +174,9 @@ class StopInfo : public std::enable_shared_from_this<StopInfo> {
   static lldb::StopInfoSP
   CreateStopReasonHistoryBoundary(Thread &thread, const char *description);
 
+  static lldb::StopInfoSP
+  CreateStopReasonDyld(Thread &thread, const char *description = nullptr);
+
   static lldb::StopInfoSP CreateStopReasonFork(Thread &thread,
                                                lldb::pid_t child_pid,
                                                lldb::tid_t child_tid);

lldb/include/lldb/Target/Target.h

@@ -1562,6 +1562,21 @@ class Target : public std::enable_shared_from_this<Target>,
   /// Print all the signals set in this target.
   void PrintDummySignals(Stream &strm, Args &signals);
 
+
+  lldb::TargetSP GetGPUPluginTarget(llvm::StringRef plugin_name) {
+    return m_gpu_plugin_targets.lookup(plugin_name).lock();
+  }
+
+  void SetGPUPluginTarget(llvm::StringRef plugin_name, 
+                          lldb::TargetSP target_sp) {
+    m_native_target_gpu_wp = shared_from_this();
+    m_gpu_plugin_targets[plugin_name] = target_sp;
+  }
+
+  lldb::TargetSP GetNativeTargetForGPU() {
+    return m_native_target_gpu_wp.lock();
+  }
+
 protected:
   /// Implementing of ModuleList::Notifier.
 
@@ -1650,6 +1665,14 @@ class Target : public std::enable_shared_from_this<Target>,
   /// signals you will have.
   llvm::StringMap<DummySignalValues> m_dummy_signals;
 
+  /// If a process spawns another target for a GPU plug-in, this map tracks the
+  /// associated plug-in targets so they can be accessed.
+  llvm::StringMap<lldb::TargetWP> m_gpu_plugin_targets;
+  /// If a target has a parent target, this can be used to synchronize the two
+  /// targets. For example if a GPU target wants to resume but it requires its
+  /// native target to resume as well, we can use this to make this happen.
+  lldb::TargetWP m_native_target_gpu_wp;
+
   static void ImageSearchPathsChanged(const PathMappingList &path_list,
                                       void *baton);
 

lldb/include/lldb/Utility/ArchSpec.h

@@ -236,6 +236,12 @@ class ArchSpec {
 
     eCore_wasm32,
 
+    eCore_amd_gpu_r600,
+    eCore_amd_gpu_gcn,
+
+    eCore_nvidia_nvptx,
+    eCore_nvidia_nvptx64,
+
     kNumCores,
 
     kCore_invalid,

lldb/include/lldb/Utility/GDBRemote.h

@@ -14,11 +14,11 @@
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-public.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/JSON.h"
 
 #include <cstddef>
 #include <cstdint>
 #include <string>
-#include <vector>
 
 namespace lldb_private {
 
@@ -43,6 +43,62 @@ class StreamGDBRemote : public StreamString {
   ///     Number of bytes written.
   // TODO: Convert this function to take ArrayRef<uint8_t>
   int PutEscapedBytes(const void *s, size_t src_len);
+
+  /// Convert an object into JSON and add the JSON text to the packet.
+  ///
+  /// Any special characters in the JSON will be escaped to make sure it doesn't
+  /// interfere with the GDB remote protocol packet format.
+  ///
+  /// \param[in] obj
+  ///     The object to convert to JSON which must have a method written that
+  ///     converts the object to a llvm::json::Value:
+  ///
+  ///     \code llvm::json::Value toJSON(const T &obj);
+  ///
+  /// \param[in] hex_ascii
+  ///     If \a true then encode JSON as hex ASCII bytes. If \a false, then
+  ///     encode as an escaped string value.
+  ///
+  /// \return
+  ///     Number of bytes written.
+  template<class T> int PutAsJSON(const T &obj, bool hex_ascii) {
+    std::string json_string;
+    llvm::raw_string_ostream os(json_string);
+    os << toJSON(obj);
+    if (hex_ascii)
+      return PutStringAsRawHex8(json_string);
+    else
+      return PutEscapedBytes(json_string.c_str(), json_string.size());  
+  }
+  /// Convert an array of objects into JSON and add the JSON text to the packet.
+  ///
+  /// Any special characters in the JSON will be escaped to make sure it doesn't
+  /// interfere with the GDB remote protocol packet format.
+  ///
+  /// \param[in] array
+  ///     An array of objects to convert to JSON. The object't type must have a 
+  ///     method written that converts the object to a llvm::json::Value:
+  ///
+  ///     \code llvm::json::Value toJSON(const T &obj);
+  ///
+  /// \return
+  ///     Number of bytes written.
+  template<class T> int PutAsJSONArray(const std::vector<T> &array) {
+    std::string json_string;
+    llvm::raw_string_ostream os(json_string);
+    bool first = true;
+    os << "[";
+    for (auto &obj: array) {
+      if (first)
+        first = false;
+      else
+        os << ",";
+      os << toJSON(obj);
+    }
+    os << "]";
+    return PutEscapedBytes(json_string.data(), json_string.size());
+  }
+
 };
 
 /// GDB remote packet as used by the GDB remote communication history. Packets