Updated after building lldb-server

Author: DhruvSrivastavaX

lldb/cmake/modules/LLDBConfig.cmake

@@ -292,7 +292,7 @@ endif()
 
 # Figure out if lldb could use lldb-server.  If so, then we'll
 # ensure we build lldb-server when an lldb target is being built.
-if (CMAKE_SYSTEM_NAME MATCHES "Android|Darwin|FreeBSD|Linux|NetBSD|OpenBSD|Windows")
+if (CMAKE_SYSTEM_NAME MATCHES "Android|Darwin|FreeBSD|Linux|NetBSD|OpenBSD|Windows|AIX")
   set(LLDB_CAN_USE_LLDB_SERVER ON)
 else()
   set(LLDB_CAN_USE_LLDB_SERVER OFF)

lldb/source/Plugins/Process/AIX/CMakeLists.txt

@@ -12,3 +12,5 @@ add_lldb_library(lldbPluginProcessAIX
   LINK_COMPONENTS
     Support
   )
+
+target_compile_definitions(lldbPluginProcessAIX PRIVATE "-D_ALL_SOURCE")

lldb/source/Plugins/Process/AIX/NativeProcessAIX.cpp

@@ -7,9 +7,11 @@
 //===----------------------------------------------------------------------===//
 
 #include "NativeProcessAIX.h"
+#include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostProcess.h"
 #include "lldb/Host/ProcessLaunchInfo.h"
+#include "lldb/Host/posix/ProcessLauncherPosixFork.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/State.h"
@@ -21,6 +23,7 @@
 #include <cstring>
 #include <sstream>
 #include <string>
+#include <sys/ptrace.h>
 #include <unistd.h>
 
 using namespace lldb;
@@ -34,17 +37,17 @@ static_assert(sizeof(long) >= k_ptrace_word_size,
 
 // Simple helper function to ensure flags are enabled on the given file
 // descriptor.
-static llvm::Error EnsureFDFlags(int fd, int flags) {
-  Error error;
+static Status EnsureFDFlags(int fd, int flags) {
+  Status error;
 
   int status = fcntl(fd, F_GETFL);
   if (status == -1) {
-    error = errorCodeToError(errnoAsErrorCode());
+    error = Status::FromErrno();
     return error;
   }
 
   if (fcntl(fd, F_SETFL, status | flags) == -1) {
-    error = errorCodeToError(errnoAsErrorCode());
+    error = Status::FromErrno();
     return error;
   }
 
@@ -123,6 +126,10 @@ NativeProcessAIX::Manager::Attach(
       pid, -1, native_delegate, Info.GetArchitecture(), *this, *tids_or));
 }
 
+lldb::addr_t NativeProcessAIX::GetSharedLibraryInfoAddress() {
+  return LLDB_INVALID_ADDRESS;
+}
+
 NativeProcessAIX::Extension
 NativeProcessAIX::Manager::GetSupportedExtensions() const {
   NativeProcessAIX::Extension supported = {};
@@ -155,7 +162,8 @@ NativeProcessAIX::NativeProcessAIX(::pid_t pid, int terminal_fd,
 
 llvm::Expected<std::vector<::pid_t>> NativeProcessAIX::Attach(::pid_t pid) {
 
-  Error status;
+  Log *log = GetLog(POSIXLog::Process);
+  Status status;
   if ((status = PtraceWrapper(PT_ATTACH, pid)).Fail()) {
     return errorCodeToError(errnoAsErrorCode());
   }
@@ -172,59 +180,76 @@ llvm::Expected<std::vector<::pid_t>> NativeProcessAIX::Attach(::pid_t pid) {
   return std::move(tids);
 }
 
-void NativeProcessAIX::MonitorSIGTRAP(const WaitStatus status,
-                                      NativeThreadAIX &thread) {}
-
-void NativeProcessAIX::MonitorBreakpoint(NativeThreadAIX &thread) {}
-
 bool NativeProcessAIX::SupportHardwareSingleStepping() const { return false; }
 
 Status NativeProcessAIX::Resume(const ResumeActionList &resume_actions) {
   return Status();
 }
 
-Error NativeProcessAIX::Halt() {
-  Error error;
+Status NativeProcessAIX::Halt() {
+  Status error;
   return error;
 }
 
-Error NativeProcessAIX::Detach() {
-  Error error;
+Status NativeProcessAIX::Detach() {
+  Status error;
   return error;
 }
 
-Error NativeProcessAIX::Signal(int signo) {
-  Error error;
+Status NativeProcessAIX::Signal(int signo) {
+  Status error;
   return error;
 }
 
-Error NativeProcessAIX::Interrupt() { return Status(); }
+Status NativeProcessAIX::Interrupt() { return Status(); }
 
-Error NativeProcessAIX::Kill() {
-  Error error;
+Status NativeProcessAIX::Kill() {
+  Status error;
   return error;
 }
 
-Error NativeProcessAIX::SetBreakpoint(lldb::addr_t addr, uint32_t size,
-                                      bool hardware) {
+Status NativeProcessAIX::ReadMemory(lldb::addr_t addr, void *buf, size_t size,
+                                    size_t &bytes_read) {
+  return Status();
+}
+
+Status NativeProcessAIX::WriteMemory(lldb::addr_t addr, const void *buf,
+                                     size_t size, size_t &bytes_written) {
+  return Status();
+}
+
+size_t NativeProcessAIX::UpdateThreads() {
+  // The NativeProcessAIX monitoring threads are always up to date with
+  // respect to thread state and they keep the thread list populated properly.
+  // All this method needs to do is return the thread count.
+  return m_threads.size();
+}
+
+Status NativeProcessAIX::GetLoadedModuleFileSpec(const char *module_path,
+                                                 FileSpec &file_spec) {
+  return Status();
+}
+
+Status NativeProcessAIX::SetBreakpoint(lldb::addr_t addr, uint32_t size,
+                                       bool hardware) {
   if (hardware)
     return SetHardwareBreakpoint(addr, size);
   else
     return SetSoftwareBreakpoint(addr, size);
 }
 
-Error NativeProcessAIX::RemoveBreakpoint(lldb::addr_t addr, bool hardware) {
+Status NativeProcessAIX::RemoveBreakpoint(lldb::addr_t addr, bool hardware) {
   if (hardware)
     return RemoveHardwareBreakpoint(addr);
   else
     return NativeProcessProtocol::RemoveBreakpoint(addr);
 }
 
-int8_t NativeProcessAIX::GetSignalInfo(WaitStatus wstatus) const {
-  return wstatus.status;
+Status NativeProcessAIX::GetSignalInfo(lldb::tid_t tid, void *siginfo) const {
+  return Status();
 }
 
-Error NativeProcessAIX::Detach(lldb::tid_t tid) {
+Status NativeProcessAIX::Detach(lldb::tid_t tid) {
   if (tid == LLDB_INVALID_THREAD_ID)
     return Status();
 
@@ -233,10 +258,10 @@ Error NativeProcessAIX::Detach(lldb::tid_t tid) {
 
 // Wrapper for ptrace to catch errors and log calls. Note that ptrace sets
 // errno on error because -1 can be a valid result (i.e. for PTRACE_PEEK*)
-Error NativeProcessAIX::PtraceWrapper(int req, lldb::pid_t pid, void *addr,
-                                      void *data, size_t data_size,
-                                      long *result) {
-  Error error;
+Status NativeProcessAIX::PtraceWrapper(int req, lldb::pid_t pid, void *addr,
+                                       void *data, size_t data_size,
+                                       long *result) {
+  Status error;
   long int ret;
 
   Log *log = GetLog(POSIXLog::Ptrace);
@@ -252,7 +277,7 @@ Error NativeProcessAIX::PtraceWrapper(int req, lldb::pid_t pid, void *addr,
   }
 
   if (errno) {
-    error = errorCodeToError(errnoAsErrorCode());
+    error = Status::FromErrno();
     ret = -1;
   }
 

lldb/source/Plugins/Process/AIX/NativeProcessAIX.h

@@ -12,6 +12,7 @@
 #include "Plugins/Process/Utility/NativeProcessSoftwareSingleStep.h"
 #include "lldb/Host/Debug.h"
 #include "lldb/Host/common/NativeProcessProtocol.h"
+#include "lldb/Host/linux/Support.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/FileSpec.h"
@@ -20,9 +21,7 @@
 #include <csignal>
 #include <unordered_set>
 
-namespace lldb_private {
-
-namespace process_aix {
+namespace lldb_private::process_aix {
 /// \class NativeProcessAIX
 /// Manages communication with the inferior (debugee) process.
 ///
@@ -78,20 +77,44 @@ class NativeProcessAIX : public NativeProcessProtocol {
 
   Status Kill() override;
 
+  lldb::addr_t GetSharedLibraryInfoAddress() override;
+
+  Status ReadMemory(lldb::addr_t addr, void *buf, size_t size,
+                    size_t &bytes_read) override;
+
+  Status WriteMemory(lldb::addr_t addr, const void *buf, size_t size,
+                     size_t &bytes_written) override;
+
+  size_t UpdateThreads() override;
+
   const ArchSpec &GetArchitecture() const override { return m_arch; }
 
   Status SetBreakpoint(lldb::addr_t addr, uint32_t size,
                        bool hardware) override;
 
   Status RemoveBreakpoint(lldb::addr_t addr, bool hardware = false) override;
 
+  Status GetLoadedModuleFileSpec(const char *module_path,
+                                 FileSpec &file_spec) override;
+
+  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
+  GetAuxvData() const override {
+    return getProcFile(GetID(), "auxv");
+  }
+
   Status GetFileLoadAddress(const llvm::StringRef &file_name,
                             lldb::addr_t &load_addr) override;
 
   static Status PtraceWrapper(int req, lldb::pid_t pid, void *addr = nullptr,
                               void *data = nullptr, size_t data_size = 0,
                               long *result = nullptr);
 
+  bool SupportHardwareSingleStepping() const;
+
+  /// Writes a siginfo_t structure corresponding to the given thread ID to the
+  /// memory region pointed to by \p siginfo.
+  Status GetSignalInfo(lldb::tid_t tid, void *siginfo) const;
+
 private:
   Manager &m_manager;
   ArchSpec m_arch;
@@ -104,16 +127,11 @@ class NativeProcessAIX : public NativeProcessProtocol {
   // Returns a list of process threads that we have attached to.
   static llvm::Expected<std::vector<::pid_t>> Attach(::pid_t pid);
 
-  void MonitorSIGTRAP(const WaitStatus status, NativeThreadAIX &thread);
-
-  void MonitorBreakpoint(NativeThreadAIX &thread);
-
   Status Detach(lldb::tid_t tid);
 
   void SigchldHandler();
 };
 
-} // namespace process_aix
-} // namespace lldb_private
+} // namespace lldb_private::process_aix
 
 #endif // #ifndef LIBLLDB_NATIVEPROCESSAIX_H_

lldb/tools/lldb-server/CMakeLists.txt

@@ -8,6 +8,10 @@ if(CMAKE_SYSTEM_NAME MATCHES "Linux|Android")
   list(APPEND LLDB_PLUGINS lldbPluginProcessLinux)
 endif()
 
+if(CMAKE_SYSTEM_NAME MATCHES "AIX")
+    list(APPEND LLDB_PLUGINS lldbPluginProcessAIX)
+endif()
+
 if(CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
   list(APPEND LLDB_PLUGINS lldbPluginProcessFreeBSD)
 endif()