Move ProcessInstanceInfo and similar to Utility

[zturner]

Summary

There are set of classes in Target that describe the parameters of a process - e.g. it's PID, name, user id, and similar. However, since it is a bare description of a process and contains no actual functionality, there's nothing specifically that makes this appropriate for being in Target -- it could just as well be describing a process on the host, or some hypothetical virtual process that doesn't even exist.

To cement this, I'm moving this class to Utility. It's possible that we can find a better place for it in the future, but as it is neither Host specific nor Target specific, Utility seems like the most appropriate place for the time being.

After this there are only 2 remaining references to Target from Host, neither of which is terribly difficult to fix on its own and which I'll address in followups.

[labath]

My main reason for creating D58167 was so that this move (*) could be done without leaving the remnants of the Dump function in the form DumpProcessInstance functions in Process.cpp (among other benefits I think that refactoring will bring). I still think it would be better to do this in that order, but if takes too long to get that patch accepted (I'm not sure what's the holdup, maybe people just don't care enough about that?), then we can do things in the opposite order too (or just drop the second patch, if noone's interested in it).

(*) I was originally planning to move these into Host (and I have actually already moved some of them recently, which is why some of these classes are in Host and others in Target). I did that because Host already contains code for working with processes and there's no problem in Target depending on Host, so it was "good enough". However, the case for Utility also sounds reasonable to me, so I am fine with that option too.

[labath]

Hmm.. I think I've thought of (or remembered, because I have been thinking about Utility too) a reason why it might be better to keep these in Host. ProcessLaunchInfo cannot be trivially moved to Utility (and indeed, in this patch, you are keeping it in Host), because it contains some references to Host-specific code (PTY stuff). Now, I am not convinced having the PTY class be a member of ProcessLaunchInfo is a good thing, but assuming we don't want to refactor that now, I think it might be better to keep Process(Launch)Info and friends in the same package (i.e., in Host), at least until we have a reason to do otherwise.

[zturner]

In D58842#1415526, @labath wrote:

Hmm.. I think I've thought of (or remembered, because I have been thinking about Utility too) a reason why it might be better to keep these in Host. ProcessLaunchInfo cannot be trivially moved to Utility (and indeed, in this patch, you are keeping it in Host), because it contains some references to Host-specific code (PTY stuff). Now, I am not convinced having the PTY class be a member of ProcessLaunchInfo is a good thing, but assuming we don't want to refactor that now, I think it might be better to keep Process(Launch)Info and friends in the same package (i.e., in Host), at least until we have a reason to do otherwise.

Well, the biggest difference between ProcessAttachInfo / ProcessLaunchInfo and the ones here is that those actually have some non-trivial functionality associated with them. It might be possible to decouple that functionality from the descriptions themselves, but it didn't seem worth it to me.

I have a mild preference for putting them in Utility on the grounds that logically that's where they seem to make the most sense. A Process could just as easily be running on a target as on the host, and we may want to pass this description around, and so favoring one or the other regarding to put them seemed a bit biased. We do already have a process class in Host called HostProcess, and that's more what I envision a host-specific process looking like. Low level methods that map directly to system calls to manipulate and query a process's state, etc.

As for D58167, I mostly just had a drive-by passing comment, and it looked fine to me after that, but I guess I was waiting for someone else to click Accept since my comment was fairly minor. But I'll go ahead and accept it anyway just to unblock

[labath]

In D58842#1415542, @zturner wrote:

In D58842#1415526, @labath wrote:

Hmm.. I think I've thought of (or remembered, because I have been thinking about Utility too) a reason why it might be better to keep these in Host. ProcessLaunchInfo cannot be trivially moved to Utility (and indeed, in this patch, you are keeping it in Host), because it contains some references to Host-specific code (PTY stuff). Now, I am not convinced having the PTY class be a member of ProcessLaunchInfo is a good thing, but assuming we don't want to refactor that now, I think it might be better to keep Process(Launch)Info and friends in the same package (i.e., in Host), at least until we have a reason to do otherwise.

Well, the biggest difference between ProcessAttachInfo / ProcessLaunchInfo and the ones here is that those actually have some non-trivial functionality associated with them. It might be possible to decouple that functionality from the descriptions themselves, but it didn't seem worth it to me.

I agree it's not a top priority, but I think it would be nice to factor that out. The reason for that is that ProcessLaunchInfo is also used to describe remote launches, and in this case, having a Host PTY around doesn't make sense (we might (and we do) want to have a flag that says a pty should be used on the remote side, but an actual host pty object does not make sense there).

I have a mild preference for putting them in Utility on the grounds that logically that's where they seem to make the most sense. A Process could just as easily be running on a target as on the host, and we may want to pass this description around, and so favoring one or the other regarding to put them seemed a bit biased. We do already have a process class in Host called HostProcess, and that's more what I envision a host-specific process looking like. Low level methods that map directly to system calls to manipulate and query a process's state, etc.

Ok, I am fine with putting this in Utility then (unless someone else speaks up about his preference for the location of this). In the future, I am starting to think we could have a new package (name TBD) which would contain things that "describe some property of a process, but without any bias towards a particular implementation of the process (Target, Host, lldb-server, ...)". I will soon need to move MemoryRegionInfo out of Utility and into something else, and it seems to me this class could fit that description too.

As for D58167, I mostly just had a drive-by passing comment, and it looked fine to me after that, but I guess I was waiting for someone else to click Accept since my comment was fairly minor. But I'll go ahead and accept it anyway just to unblock

Ok so it seems it's not clear if I answered all of Greg's comments or not. Let's wait to see if he has anything to say until monday. If that patch takes longer, then you commit this, and I'll rebase that patch on top of this.

lldb/include/lldb/Host/Host.h

 #include <stdarg.h>
 #include <string>
 #include <type_traits>
 
 namespace lldb_private {
 
 class FileAction;
 class ProcessLaunchInfo;
+class ProcessInstanceInfo;
+class ProcessInstanceInfoList;
+class ProcessInstanceInfoMatch;
 
 //----------------------------------------------------------------------
 // Exit Type for inferior processes
 //----------------------------------------------------------------------
 struct WaitStatus {
   enum Type : uint8_t {
     Exit,   // The status represents the return code from normal
             // program exit (i.e. WIFEXITED() was true)

lldb/include/lldb/Host/ProcessInfo.h

-//===-- ProcessInfo.h -------------------------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef liblldb_ProcessInfo_h_
-#define liblldb_ProcessInfo_h_
-
-// LLDB headers
-#include "lldb/Utility/ArchSpec.h"
-#include "lldb/Utility/Args.h"
-#include "lldb/Utility/Environment.h"
-#include "lldb/Utility/FileSpec.h"
-
-namespace lldb_private {
-//----------------------------------------------------------------------
-// ProcessInfo
-//
-// A base class for information for a process. This can be used to fill
-// out information for a process prior to launching it, or it can be used for
-// an instance of a process and can be filled in with the existing values for
-// that process.
-//----------------------------------------------------------------------
-class ProcessInfo {
-public:
-  ProcessInfo();
-
-  ProcessInfo(const char *name, const ArchSpec &arch, lldb::pid_t pid);
-
-  void Clear();
-
-  const char *GetName() const;
-
-  size_t GetNameLength() const;
-
-  FileSpec &GetExecutableFile() { return m_executable; }
-
-  void SetExecutableFile(const FileSpec &exe_file,
-                         bool add_exe_file_as_first_arg);
-
-  const FileSpec &GetExecutableFile() const { return m_executable; }
-
-  uint32_t GetUserID() const { return m_uid; }
-
-  uint32_t GetGroupID() const { return m_gid; }
-
-  bool UserIDIsValid() const { return m_uid != UINT32_MAX; }
-
-  bool GroupIDIsValid() const { return m_gid != UINT32_MAX; }
-
-  void SetUserID(uint32_t uid) { m_uid = uid; }
-
-  void SetGroupID(uint32_t gid) { m_gid = gid; }
-
-  ArchSpec &GetArchitecture() { return m_arch; }
-
-  const ArchSpec &GetArchitecture() const { return m_arch; }
-
-  void SetArchitecture(const ArchSpec &arch) { m_arch = arch; }
-
-  lldb::pid_t GetProcessID() const { return m_pid; }
-
-  void SetProcessID(lldb::pid_t pid) { m_pid = pid; }
-
-  bool ProcessIDIsValid() const { return m_pid != LLDB_INVALID_PROCESS_ID; }
-
-  void Dump(Stream &s, Platform *platform) const;
-
-  Args &GetArguments() { return m_arguments; }
-
-  const Args &GetArguments() const { return m_arguments; }
-
-  llvm::StringRef GetArg0() const;
-
-  void SetArg0(llvm::StringRef arg);
-
-  void SetArguments(const Args &args, bool first_arg_is_executable);
-
-  void SetArguments(char const **argv, bool first_arg_is_executable);
-
-  Environment &GetEnvironment() { return m_environment; }
-  const Environment &GetEnvironment() const { return m_environment; }
-
-protected:
-  FileSpec m_executable;
-  std::string m_arg0; // argv[0] if supported. If empty, then use m_executable.
-  // Not all process plug-ins support specifying an argv[0] that differs from
-  // the resolved platform executable (which is in m_executable)
-  Args m_arguments; // All program arguments except argv[0]
-  Environment m_environment;
-  uint32_t m_uid;
-  uint32_t m_gid;
-  ArchSpec m_arch;
-  lldb::pid_t m_pid;
-};
-}
-
-#endif // #ifndef liblldb_ProcessInfo_h_

lldb/include/lldb/Host/ProcessLaunchInfo.h

 // C++ Headers
 #include <string>
 
 // LLDB Headers
 #include "lldb/Utility/Flags.h"
 
 #include "lldb/Host/FileAction.h"
 #include "lldb/Host/Host.h"
-#include "lldb/Host/ProcessInfo.h"
 #include "lldb/Host/PseudoTerminal.h"
 #include "lldb/Utility/FileSpec.h"
+#include "lldb/Utility/ProcessInfo.h"
 
 namespace lldb_private {
 
 //----------------------------------------------------------------------
 // ProcessLaunchInfo
 //
 // Describes any information that is required to launch a process.
 //----------------------------------------------------------------------

lldb/include/lldb/Target/Platform.h

 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Timeout.h"
 #include "lldb/lldb-private-forward.h"
 #include "lldb/lldb-public.h"
 #include "llvm/Support/VersionTuple.h"
 
 namespace lldb_private {
 
+class ProcessInstanceInfo;
+class ProcessInstanceInfoList;
+class ProcessInstanceInfoMatch;
+
 class ModuleCache;
 enum MmapFlags { eMmapFlagsPrivate = 1, eMmapFlagsAnon = 2 };
 
 class PlatformProperties : public Properties {
 public:
   PlatformProperties();
 
   static ConstString GetSettingName();

lldb/include/lldb/Target/Process.h

 
 #include "lldb/Breakpoint/BreakpointSiteList.h"
 #include "lldb/Core/Communication.h"
 #include "lldb/Core/LoadedModuleInfoList.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Core/ThreadSafeValue.h"
 #include "lldb/Core/UserSettingsController.h"
 #include "lldb/Host/HostThread.h"
-#include "lldb/Host/ProcessInfo.h"
 #include "lldb/Host/ProcessLaunchInfo.h"
 #include "lldb/Host/ProcessRunLock.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/ExecutionContextScope.h"
 #include "lldb/Target/InstrumentationRuntime.h"
 #include "lldb/Target/Memory.h"
 #include "lldb/Target/QueueList.h"
 #include "lldb/Target/ThreadList.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/Broadcaster.h"
 #include "lldb/Utility/Event.h"
 #include "lldb/Utility/Listener.h"
 #include "lldb/Utility/NameMatches.h"
+#include "lldb/Utility/ProcessInfo.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StructuredData.h"
 #include "lldb/Utility/TraceOptions.h"
 #include "lldb/lldb-private.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/VersionTuple.h"
 
protected:
   static void OptionValueChangedCallback(void *baton,
                                          OptionValue *option_value);
 
   Process *m_process; // Can be nullptr for global ProcessProperties
 };
 
 typedef std::shared_ptr<ProcessProperties> ProcessPropertiesSP;
 
-//----------------------------------------------------------------------
-// ProcessInstanceInfo
-//
-// Describes an existing process and any discoverable information that pertains
-// to that process.
-//----------------------------------------------------------------------
-class ProcessInstanceInfo : public ProcessInfo {
-public:
-  ProcessInstanceInfo()
-      : ProcessInfo(), m_euid(UINT32_MAX), m_egid(UINT32_MAX),
-        m_parent_pid(LLDB_INVALID_PROCESS_ID) {}
-
-  ProcessInstanceInfo(const char *name, const ArchSpec &arch, lldb::pid_t pid)
-      : ProcessInfo(name, arch, pid), m_euid(UINT32_MAX), m_egid(UINT32_MAX),
-        m_parent_pid(LLDB_INVALID_PROCESS_ID) {}
-
-  void Clear() {
-    ProcessInfo::Clear();
-    m_euid = UINT32_MAX;
-    m_egid = UINT32_MAX;
-    m_parent_pid = LLDB_INVALID_PROCESS_ID;
-  }
-
-  uint32_t GetEffectiveUserID() const { return m_euid; }
-
-  uint32_t GetEffectiveGroupID() const { return m_egid; }
-
-  bool EffectiveUserIDIsValid() const { return m_euid != UINT32_MAX; }
-
-  bool EffectiveGroupIDIsValid() const { return m_egid != UINT32_MAX; }
-
-  void SetEffectiveUserID(uint32_t uid) { m_euid = uid; }
-
-  void SetEffectiveGroupID(uint32_t gid) { m_egid = gid; }
-
-  lldb::pid_t GetParentProcessID() const { return m_parent_pid; }
-
-  void SetParentProcessID(lldb::pid_t pid) { m_parent_pid = pid; }
-
-  bool ParentProcessIDIsValid() const {
-    return m_parent_pid != LLDB_INVALID_PROCESS_ID;
-  }
+void DumpProcessInstance(Stream &s, const ProcessInstanceInfo &process,
+                         Platform *platform);
 
-  void Dump(Stream &s, Platform *platform) const;
+void DumpProcessInstanceTableHeader(Stream &s, Platform *platform,
+                                    bool show_args, bool verbose);
 
-  static void DumpTableHeader(Stream &s, Platform *platform, bool show_args,
+void DumpProcessInstanceAsTableRow(Stream &s,
+                                   const ProcessInstanceInfo &process,
+                                   Platform *platform, bool show_args,
                                    bool verbose);
 
-  void DumpAsTableRow(Stream &s, Platform *platform, bool show_args,
-                      bool verbose) const;
-
-protected:
-  uint32_t m_euid;
-  uint32_t m_egid;
-  lldb::pid_t m_parent_pid;
-};
-
 //----------------------------------------------------------------------
 // ProcessAttachInfo
 //
 // Describes any information that is required to attach to a process.
 //----------------------------------------------------------------------
 
 class ProcessAttachInfo : public ProcessInstanceInfo {
 public:
public:
   llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
 
   // Instance variables to hold the values for command options.
 
   ProcessLaunchInfo launch_info;
   lldb_private::LazyBool disable_aslr;
 };
 
-//----------------------------------------------------------------------
-// ProcessInstanceInfoMatch
-//
-// A class to help matching one ProcessInstanceInfo to another.
-//----------------------------------------------------------------------
-
-class ProcessInstanceInfoMatch {
-public:
-  ProcessInstanceInfoMatch()
-      : m_match_info(), m_name_match_type(NameMatch::Ignore),
-        m_match_all_users(false) {}
-
-  ProcessInstanceInfoMatch(const char *process_name,
-                           NameMatch process_name_match_type)
-      : m_match_info(), m_name_match_type(process_name_match_type),
-        m_match_all_users(false) {
-    m_match_info.GetExecutableFile().SetFile(process_name,
-                                             FileSpec::Style::native);
-  }
-
-  ProcessInstanceInfo &GetProcessInfo() { return m_match_info; }
-
-  const ProcessInstanceInfo &GetProcessInfo() const { return m_match_info; }
-
-  bool GetMatchAllUsers() const { return m_match_all_users; }
-
-  void SetMatchAllUsers(bool b) { m_match_all_users = b; }
-
-  NameMatch GetNameMatchType() const { return m_name_match_type; }
-
-  void SetNameMatchType(NameMatch name_match_type) {
-    m_name_match_type = name_match_type;
-  }
-
-  bool NameMatches(const char *process_name) const;
-
-  bool Matches(const ProcessInstanceInfo &proc_info) const;
-
-  bool MatchAllProcesses() const;
-  void Clear();
-
-protected:
-  ProcessInstanceInfo m_match_info;
-  NameMatch m_name_match_type;
-  bool m_match_all_users;
-};
-
-class ProcessInstanceInfoList {
-public:
-  ProcessInstanceInfoList() = default;
-
-  void Clear() { m_infos.clear(); }
-
-  size_t GetSize() { return m_infos.size(); }
-
-  void Append(const ProcessInstanceInfo &info) { m_infos.push_back(info); }
-
-  const char *GetProcessNameAtIndex(size_t idx) {
-    return ((idx < m_infos.size()) ? m_infos[idx].GetName() : nullptr);
-  }
-
-  size_t GetProcessNameLengthAtIndex(size_t idx) {
-    return ((idx < m_infos.size()) ? m_infos[idx].GetNameLength() : 0);
-  }
-
-  lldb::pid_t GetProcessIDAtIndex(size_t idx) {
-    return ((idx < m_infos.size()) ? m_infos[idx].GetProcessID() : 0);
-  }
-
-  bool GetInfoAtIndex(size_t idx, ProcessInstanceInfo &info) {
-    if (idx < m_infos.size()) {
-      info = m_infos[idx];
-      return true;
-    }
-    return false;
-  }
-
-  // You must ensure "idx" is valid before calling this function
-  const ProcessInstanceInfo &GetProcessInfoAtIndex(size_t idx) const {
-    assert(idx < m_infos.size());
-    return m_infos[idx];
-  }
-
-protected:
-  typedef std::vector<ProcessInstanceInfo> collection;
-  collection m_infos;
-};
-
 // This class tracks the Modification state of the process.  Things that can
 // currently modify the program are running the program (which will up the
 // StopID) and writing memory (which will up the MemoryID.)
 // FIXME: Should we also include modification of register states?
 
 class ProcessModID {
   friend bool operator==(const ProcessModID &lhs, const ProcessModID &rhs);
 

lldb/include/lldb/Utility/ProcessInfo.h

+//===-- ProcessInfo.h -------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_UTILITY_PROCESSINFO_H
+#define LLDB_UTILITY_PROCESSINFO_H
+
+// LLDB headers
+#include "lldb/Utility/ArchSpec.h"
+#include "lldb/Utility/Args.h"
+#include "lldb/Utility/Environment.h"
+#include "lldb/Utility/FileSpec.h"
+#include "lldb/Utility/NameMatches.h"
+
+#include <vector>
+
+namespace lldb_private {
+//----------------------------------------------------------------------
+// ProcessInfo
+//
+// A base class for information for a process. This can be used to fill
+// out information for a process prior to launching it, or it can be used for
+// an instance of a process and can be filled in with the existing values for
+// that process.
+//----------------------------------------------------------------------
+class ProcessInfo {
+public:
+  ProcessInfo();
+
+  ProcessInfo(const char *name, const ArchSpec &arch, lldb::pid_t pid);
+
+  void Clear();
+
+  const char *GetName() const;
+
+  size_t GetNameLength() const;
+
+  FileSpec &GetExecutableFile() { return m_executable; }
+
+  void SetExecutableFile(const FileSpec &exe_file,
+                         bool add_exe_file_as_first_arg);
+
+  const FileSpec &GetExecutableFile() const { return m_executable; }
+
+  uint32_t GetUserID() const { return m_uid; }
+
+  uint32_t GetGroupID() const { return m_gid; }
+
+  bool UserIDIsValid() const { return m_uid != UINT32_MAX; }
+
+  bool GroupIDIsValid() const { return m_gid != UINT32_MAX; }
+
+  void SetUserID(uint32_t uid) { m_uid = uid; }
+
+  void SetGroupID(uint32_t gid) { m_gid = gid; }
+
+  ArchSpec &GetArchitecture() { return m_arch; }
+
+  const ArchSpec &GetArchitecture() const { return m_arch; }
+
+  void SetArchitecture(const ArchSpec &arch) { m_arch = arch; }
+
+  lldb::pid_t GetProcessID() const { return m_pid; }
+
+  void SetProcessID(lldb::pid_t pid) { m_pid = pid; }
+
+  bool ProcessIDIsValid() const { return m_pid != LLDB_INVALID_PROCESS_ID; }
+
+  void Dump(Stream &s, Platform *platform) const;
+
+  Args &GetArguments() { return m_arguments; }
+
+  const Args &GetArguments() const { return m_arguments; }
+
+  llvm::StringRef GetArg0() const;
+
+  void SetArg0(llvm::StringRef arg);
+
+  void SetArguments(const Args &args, bool first_arg_is_executable);
+
+  void SetArguments(char const **argv, bool first_arg_is_executable);
+
+  Environment &GetEnvironment() { return m_environment; }
+  const Environment &GetEnvironment() const { return m_environment; }
+
+protected:
+  FileSpec m_executable;
+  std::string m_arg0; // argv[0] if supported. If empty, then use m_executable.
+  // Not all process plug-ins support specifying an argv[0] that differs from
+  // the resolved platform executable (which is in m_executable)
+  Args m_arguments; // All program arguments except argv[0]
+  Environment m_environment;
+  uint32_t m_uid;
+  uint32_t m_gid;
+  ArchSpec m_arch;
+  lldb::pid_t m_pid;
+};
+
+//----------------------------------------------------------------------
+// ProcessInstanceInfo
+//
+// Describes an existing process and any discoverable information that pertains
+// to that process.
+//----------------------------------------------------------------------
+class ProcessInstanceInfo : public ProcessInfo {
+public:
+  ProcessInstanceInfo()
+      : ProcessInfo(), m_euid(UINT32_MAX), m_egid(UINT32_MAX),
+        m_parent_pid(LLDB_INVALID_PROCESS_ID) {}
+
+  ProcessInstanceInfo(const char *name, const ArchSpec &arch, lldb::pid_t pid)
+      : ProcessInfo(name, arch, pid), m_euid(UINT32_MAX), m_egid(UINT32_MAX),
+        m_parent_pid(LLDB_INVALID_PROCESS_ID) {}
+
+  void Clear() {
+    ProcessInfo::Clear();
+    m_euid = UINT32_MAX;
+    m_egid = UINT32_MAX;
+    m_parent_pid = LLDB_INVALID_PROCESS_ID;
+  }
+
+  uint32_t GetEffectiveUserID() const { return m_euid; }
+
+  uint32_t GetEffectiveGroupID() const { return m_egid; }
+
+  bool EffectiveUserIDIsValid() const { return m_euid != UINT32_MAX; }
+
+  bool EffectiveGroupIDIsValid() const { return m_egid != UINT32_MAX; }
+
+  void SetEffectiveUserID(uint32_t uid) { m_euid = uid; }
+
+  void SetEffectiveGroupID(uint32_t gid) { m_egid = gid; }
+
+  lldb::pid_t GetParentProcessID() const { return m_parent_pid; }
+
+  void SetParentProcessID(lldb::pid_t pid) { m_parent_pid = pid; }
+
+  bool ParentProcessIDIsValid() const {
+    return m_parent_pid != LLDB_INVALID_PROCESS_ID;
+  }
+
+protected:
+  uint32_t m_euid;
+  uint32_t m_egid;
+  lldb::pid_t m_parent_pid;
+};
+
+class ProcessInstanceInfoList {
+public:
+  ProcessInstanceInfoList() = default;
+
+  void Clear() { m_infos.clear(); }
+
+  size_t GetSize() { return m_infos.size(); }
+
+  void Append(const ProcessInstanceInfo &info) { m_infos.push_back(info); }
+
+  const char *GetProcessNameAtIndex(size_t idx) {
+    return ((idx < m_infos.size()) ? m_infos[idx].GetName() : nullptr);
+  }
+
+  size_t GetProcessNameLengthAtIndex(size_t idx) {
+    return ((idx < m_infos.size()) ? m_infos[idx].GetNameLength() : 0);
+  }
+
+  lldb::pid_t GetProcessIDAtIndex(size_t idx) {
+    return ((idx < m_infos.size()) ? m_infos[idx].GetProcessID() : 0);
+  }
+
+  bool GetInfoAtIndex(size_t idx, ProcessInstanceInfo &info) {
+    if (idx < m_infos.size()) {
+      info = m_infos[idx];
+      return true;
+    }
+    return false;
+  }
+
+  // You must ensure "idx" is valid before calling this function
+  const ProcessInstanceInfo &GetProcessInfoAtIndex(size_t idx) const {
+    assert(idx < m_infos.size());
+    return m_infos[idx];
+  }
+
+protected:
+  std::vector<ProcessInstanceInfo> m_infos;
+};
+
+//----------------------------------------------------------------------
+// ProcessInstanceInfoMatch
+//
+// A class to help matching one ProcessInstanceInfo to another.
+//----------------------------------------------------------------------
+
+class ProcessInstanceInfoMatch {
+public:
+  ProcessInstanceInfoMatch()
+      : m_match_info(), m_name_match_type(NameMatch::Ignore),
+        m_match_all_users(false) {}
+
+  ProcessInstanceInfoMatch(const char *process_name,
+                           NameMatch process_name_match_type)
+      : m_match_info(), m_name_match_type(process_name_match_type),
+        m_match_all_users(false) {
+    m_match_info.GetExecutableFile().SetFile(process_name,
+                                             FileSpec::Style::native);
+  }
+
+  ProcessInstanceInfo &GetProcessInfo() { return m_match_info; }
+
+  const ProcessInstanceInfo &GetProcessInfo() const { return m_match_info; }
+
+  bool GetMatchAllUsers() const { return m_match_all_users; }
+
+  void SetMatchAllUsers(bool b) { m_match_all_users = b; }
+
+  NameMatch GetNameMatchType() const { return m_name_match_type; }
+
+  void SetNameMatchType(NameMatch name_match_type) {
+    m_name_match_type = name_match_type;
+  }
+
+  bool NameMatches(const char *process_name) const;
+
+  bool Matches(const ProcessInstanceInfo &proc_info) const;
+
+  bool MatchAllProcesses() const;
+  void Clear();
+
+protected:
+  ProcessInstanceInfo m_match_info;
+  NameMatch m_name_match_type;
+  bool m_match_all_users;
+};
+
+} // namespace lldb_private
+
+#endif // #ifndef LLDB_UTILITY_PROCESSINFO_H

lldb/include/lldb/module.modulemap

module lldb_Host {
   module LockFile { header "Host/LockFile.h" export * }
   module MainLoopBase { header "Host/MainLoopBase.h" export * }
   module MainLoop { header "Host/MainLoop.h" export * }
   module MonitoringProcessLauncher { header "Host/MonitoringProcessLauncher.h" export * }
   module OptionParser { header "Host/OptionParser.h" export * }
   module PipeBase { header "Host/PipeBase.h" export * }
   module Pipe { header "Host/Pipe.h" export * }
   module PosixApi { header "Host/PosixApi.h" export * }
-  module ProcessInfo { header "Host/ProcessInfo.h" export * }
   module ProcessLauncher { header "Host/ProcessLauncher.h" export * }
   module ProcessLaunchInfo { header "Host/ProcessLaunchInfo.h" export * }
   module ProcessRunLock { header "Host/ProcessRunLock.h" export * }
   module PseudoTerminal { header "Host/PseudoTerminal.h" export * }
   module SafeMachO { header "Host/SafeMachO.h" export * }
   module SocketAddress { header "Host/SocketAddress.h" export * }
   module Socket { header "Host/Socket.h" export * }
   module StringConvert { textual header "Host/StringConvert.h" export * }

lldb/source/API/SBProcess.cpp

 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/SystemRuntime.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/ProcessInfo.h"
 #include "lldb/Utility/State.h"
 #include "lldb/Utility/Stream.h"
 
 
 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/API/SBCommandReturnObject.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBEvent.h"

lldb/source/API/SBProcessInfo.cpp

 //===-- SBProcessInfo.cpp ---------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBProcessInfo.h"
 
 #include "lldb/API/SBFileSpec.h"
-#include "lldb/Target/Process.h"
+#include "lldb/Utility/ProcessInfo.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBProcessInfo::SBProcessInfo() : m_opaque_up() {}
 
 SBProcessInfo::SBProcessInfo(const SBProcessInfo &rhs) : m_opaque_up() {
   if (rhs.IsValid()) {

lldb/source/API/SBTarget.cpp

 #include "lldb/Target/Process.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/TargetList.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/ProcessInfo.h"
 #include "lldb/Utility/RegularExpression.h"
 
 #include "Commands/CommandObjectBreakpoint.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Regex.h"
 
 using namespace lldb;

lldb/source/Commands/CommandObjectPlatform.cpp

if (platform_sp) {
         if (platform_sp) {
           Stream &ostrm = result.GetOutputStream();
 
           lldb::pid_t pid =
               m_options.match_info.GetProcessInfo().GetProcessID();
           if (pid != LLDB_INVALID_PROCESS_ID) {
             ProcessInstanceInfo proc_info;
             if (platform_sp->GetProcessInfo(pid, proc_info)) {
-              ProcessInstanceInfo::DumpTableHeader(ostrm, platform_sp.get(),
-                                                   m_options.show_args,
-                                                   m_options.verbose);
-              proc_info.DumpAsTableRow(ostrm, platform_sp.get(),
-                                       m_options.show_args, m_options.verbose);
+              DumpProcessInstanceTableHeader(ostrm, platform_sp.get(),
+                                             m_options.show_args,
+                                             m_options.verbose);
+              DumpProcessInstanceAsTableRow(ostrm, proc_info, platform_sp.get(),
               result.SetStatus(eReturnStatusSuccessFinishResult);
             } else {
               result.AppendErrorWithFormat(
                   "no process found with pid = %" PRIu64 "\n", pid);
               result.SetStatus(eReturnStatusFailed);
             }
           } else {
             ProcessInstanceInfoList proc_infos;
if (platform_sp) {
               result.AppendMessageWithFormat(
                   "%u matching process%s found on \"%s\"", matches,
                   matches > 1 ? "es were" : " was",
                   platform_sp->GetName().GetCString());
               if (match_desc)
                 result.AppendMessageWithFormat(" whose name %s \"%s\"",
                                                match_desc, match_name);
               result.AppendMessageWithFormat("\n");
-              ProcessInstanceInfo::DumpTableHeader(ostrm, platform_sp.get(),
-                                                   m_options.show_args,
-                                                   m_options.verbose);
+              DumpProcessInstanceTableHeader(ostrm, platform_sp.get(),
               for (uint32_t i = 0; i < matches; ++i) {
-                proc_infos.GetProcessInfoAtIndex(i).DumpAsTableRow(
-                    ostrm, platform_sp.get(), m_options.show_args,
-                    m_options.verbose);
+                DumpProcessInstanceAsTableRow(
+                    ostrm, proc_infos.GetProcessInfoAtIndex(i),
+                    platform_sp.get(), m_options.show_args, m_options.verbose);
               }
             }
           }
         }
       } else {
         result.AppendError("invalid args: process list takes only options\n");
         result.SetStatus(eReturnStatusFailed);
       }

lldb/source/Host/CMakeLists.txt

add_host_subdirectory(common
   common/MainLoop.cpp
   common/MonitoringProcessLauncher.cpp
   common/NativeProcessProtocol.cpp
   common/NativeRegisterContext.cpp
   common/NativeThreadProtocol.cpp
   common/NativeWatchpointList.cpp
   common/OptionParser.cpp
   common/PipeBase.cpp
-  common/ProcessInfo.cpp
   common/ProcessLaunchInfo.cpp
   common/ProcessRunLock.cpp
   common/PseudoTerminal.cpp
   common/SocketAddress.cpp
   common/Socket.cpp
   common/StringConvert.cpp
   common/TaskPool.cpp
   common/TCPSocket.cpp

lldb/source/Host/freebsd/Host.cpp

 #include <machine/elf.h>
 
 #include <dlfcn.h>
 #include <execinfo.h>
 #include <stdio.h>
 
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
-#include "lldb/Target/Process.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/NameMatches.h"
+#include "lldb/Utility/ProcessInfo.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
 #include "llvm/Support/Host.h"
 
 extern "C" {
 extern char **environ;
 }
 
+namespace lldb_private {
+class ProcessLaunchInfo;
+}
+
 using namespace lldb;
 using namespace lldb_private;
 
 static bool
 GetFreeBSDProcessArgs(const ProcessInstanceInfoMatch *match_info_ptr,
                       ProcessInstanceInfo &process_info) {
   if (!process_info.ProcessIDIsValid())
     return false;

lldb/source/Host/linux/Host.cpp

enum class ProcessState {
   Paging,
   Running,
   Sleeping,
   TracedOrStopped,
   Zombie,
 };
 }
 
+namespace lldb_private {
+class ProcessLaunchInfo;
+}
+
 static bool GetStatusInfo(::pid_t Pid, ProcessInstanceInfo &ProcessInfo,
                           ProcessState &State, ::pid_t &TracerPid) {
   auto BufferOrError = getProcFile(Pid, "status");
   if (!BufferOrError)
     return false;
 
   llvm::StringRef Rest = BufferOrError.get()->getBuffer();
   while(!Rest.empty()) {

lldb/source/Host/netbsd/Host.cpp

 
 #include <elf.h>
 #include <kvm.h>
 #include <sys/exec.h>
 #include <sys/ptrace.h>
 
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
-#include "lldb/Target/Process.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/NameMatches.h"
+#include "lldb/Utility/ProcessInfo.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
 #include "llvm/Support/Host.h"
 
 extern "C" {
 extern char **environ;
 }
 
 using namespace lldb;
 using namespace lldb_private;
 
+namespace lldb_private {
+class ProcessLaunchInfo;
+}
+
 Environment Host::GetEnvironment() { return Environment(environ); }
 
 static bool GetNetBSDProcessArgs(const ProcessInstanceInfoMatch *match_info_ptr,
                                  ProcessInstanceInfo &process_info) {
   if (!process_info.ProcessIDIsValid())
     return false;
 
   int pid = process_info.GetProcessID();

lldb/source/Host/openbsd/Host.cpp

 #include <sys/ptrace.h>
 #include <sys/sysctl.h>
 #include <sys/user.h>
 
 #include <stdio.h>
 
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
-#include "lldb/Target/Process.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/NameMatches.h"
+#include "lldb/Utility/ProcessInfo.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
 #include "llvm/Support/Host.h"
 
 extern "C" {
 extern char **environ;
 }
 
 using namespace lldb;
 using namespace lldb_private;
 
+namespace lldb_private {
+class ProcessLaunchInfo;
+}
+
 Environment Host::GetEnvironment() {
   Environment env;
   char *v;
   char **var = environ;
   for (; var != NULL && *var != NULL; ++var) {
     v = strchr(*var, (int)'-');
     if (v == NULL)
       continue;

lldb/source/Host/windows/Host.cpp

 
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/ProcessInfo.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StructuredData.h"
 
 #include "llvm/Support/ConvertUTF.h"
 
 // Windows includes
 #include <tlhelp32.h>
 

lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp

 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/Platform.h"
-#include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlanRunToAddress.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/ProcessInfo.h"
 
 #include <memory>
 
 using namespace lldb;
 using namespace lldb_private;
 
 void DynamicLoaderPOSIXDYLD::Initialize() {
   PluginManager::RegisterPlugin(GetPluginNameStatic(),

lldb/source/Plugins/Platform/MacOSX/PlatformAppleTVSimulator.cpp

 
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
-#include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/ProcessInfo.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
 #include "llvm/Support/FileSystem.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
+namespace lldb_private {
+class Process;
+}
+
 //------------------------------------------------------------------
 // Static Variables
 //------------------------------------------------------------------
 static uint32_t g_initialize_count = 0;
 
 //------------------------------------------------------------------
 // Static Functions
 //------------------------------------------------------------------

lldb/source/Plugins/Platform/MacOSX/PlatformAppleWatchSimulator.cpp

 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Target/Process.h"
-#include "lldb/Target/Target.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/ProcessInfo.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
+namespace lldb_private {
+class Process;
+}
+
 //------------------------------------------------------------------
 // Static Variables
 //------------------------------------------------------------------
 static uint32_t g_initialize_count = 0;
 
 //------------------------------------------------------------------
 // Static Functions
 //------------------------------------------------------------------

lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

 #include "lldb/Symbol/LocateSymbolFile.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/ProcessInfo.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Timer.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Threading.h"
 #include "llvm/Support/VersionTuple.h"
 
 #if defined(__APPLE__)

lldb/source/Plugins/Platform/MacOSX/PlatformiOSSimulator.cpp

 
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
-#include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/ProcessInfo.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
 #include "llvm/Support/FileSystem.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
+namespace lldb_private {
+class Process;
+}
+
 //------------------------------------------------------------------
 // Static Variables
 //------------------------------------------------------------------
 static uint32_t g_initialize_count = 0;
 
 //------------------------------------------------------------------
 // Static Functions
 //------------------------------------------------------------------

lldb/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp

 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/PosixApi.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/ProcessInfo.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/UriParser.h"
 
 #include "Plugins/Process/Utility/GDBRemoteSignals.h"
 
 using namespace lldb;
 using namespace lldb_private;

lldb/source/Target/Process.cpp

 #include "lldb/Target/TargetList.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlan.h"
 #include "lldb/Target/ThreadPlanBase.h"
 #include "lldb/Target/UnixSignals.h"
 #include "lldb/Utility/Event.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/NameMatches.h"
+#include "lldb/Utility/ProcessInfo.h"
 #include "lldb/Utility/SelectHelper.h"
 #include "lldb/Utility/State.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace std::chrono;
 
 // Comment out line below to disable memory caching, overriding the process

 }
 
 bool ProcessProperties::GetStopOnExec() const {
   const uint32_t idx = ePropertyStopOnExec;
   return m_collection_sp->GetPropertyAtIndexAsBoolean(
       nullptr, idx, g_properties[idx].default_uint_value != 0);
 }
 
-void ProcessInstanceInfo::Dump(Stream &s, Platform *platform) const {
+void lldb_private::DumpProcessInstance(Stream &s,
+                                       const ProcessInstanceInfo &proc,
+                                       Platform *platform) {
   const char *cstr;
-  if (m_pid != LLDB_INVALID_PROCESS_ID)
-    s.Printf("    pid = %" PRIu64 "\n", m_pid);
+  if (proc.GetProcessID() != LLDB_INVALID_PROCESS_ID)
+    s.Printf("    pid = %" PRIu64 "\n", proc.GetProcessID());
 
-  if (m_parent_pid != LLDB_INVALID_PROCESS_ID)
-    s.Printf(" parent = %" PRIu64 "\n", m_parent_pid);
+  if (proc.GetParentProcessID() != LLDB_INVALID_PROCESS_ID)
+    s.Printf(" parent = %" PRIu64 "\n", proc.GetParentProcessID());
 
-  if (m_executable) {
-    s.Printf("   name = %s\n", m_executable.GetFilename().GetCString());
+  if (proc.GetExecutableFile()) {
+    s.Printf("   name = %s\n",
+             proc.GetExecutableFile().GetFilename().GetCString());
     s.PutCString("   file = ");
-    m_executable.Dump(&s);
+    proc.GetExecutableFile().Dump(&s);
     s.EOL();
   }
-  const uint32_t argc = m_arguments.GetArgumentCount();
+  const uint32_t argc = proc.GetArguments().GetArgumentCount();
   if (argc > 0) {
     for (uint32_t i = 0; i < argc; i++) {
-      const char *arg = m_arguments.GetArgumentAtIndex(i);
+      const char *arg = proc.GetArguments().GetArgumentAtIndex(i);
       if (i < 10)
         s.Printf(" arg[%u] = %s\n", i, arg);
       else
         s.Printf("arg[%u] = %s\n", i, arg);
     }
   }
 
-  s.Format("{0}", m_environment);
+  s.Format("{0}", proc.GetEnvironment());
 
-  if (m_arch.IsValid()) {
+  if (proc.GetArchitecture().IsValid()) {
     s.Printf("   arch = ");
-    m_arch.DumpTriple(s);
+    proc.GetArchitecture().DumpTriple(s);
     s.EOL();
   }
 
-  if (m_uid != UINT32_MAX) {
-    cstr = platform->GetUserName(m_uid);
-    s.Printf("    uid = %-5u (%s)\n", m_uid, cstr ? cstr : "");
+  if (proc.GetUserID() != UINT32_MAX) {
+    cstr = platform->GetUserName(proc.GetUserID());
+    s.Printf("    uid = %-5u (%s)\n", proc.GetUserID(), cstr ? cstr : "");
   }
-  if (m_gid != UINT32_MAX) {
-    cstr = platform->GetGroupName(m_gid);
-    s.Printf("    gid = %-5u (%s)\n", m_gid, cstr ? cstr : "");
+  if (proc.GetGroupID() != UINT32_MAX) {
+    cstr = platform->GetGroupName(proc.GetGroupID());
+    s.Printf("    gid = %-5u (%s)\n", proc.GetGroupID(), cstr ? cstr : "");
   }
-  if (m_euid != UINT32_MAX) {
-    cstr = platform->GetUserName(m_euid);
-    s.Printf("   euid = %-5u (%s)\n", m_euid, cstr ? cstr : "");
+  if (proc.GetEffectiveUserID() != UINT32_MAX) {
+    cstr = platform->GetUserName(proc.GetEffectiveUserID());
+    s.Printf("   euid = %-5u (%s)\n", proc.GetEffectiveUserID(),
+             cstr ? cstr : "");
   }
-  if (m_egid != UINT32_MAX) {
-    cstr = platform->GetGroupName(m_egid);
-    s.Printf("   egid = %-5u (%s)\n", m_egid, cstr ? cstr : "");
+  if (proc.GetEffectiveGroupID() != UINT32_MAX) {
+    cstr = platform->GetGroupName(proc.GetEffectiveGroupID());
+    s.Printf("   egid = %-5u (%s)\n", proc.GetEffectiveGroupID(),
+             cstr ? cstr : "");
   }
 }
 
-void ProcessInstanceInfo::DumpTableHeader(Stream &s, Platform *platform,
-                                          bool show_args, bool verbose) {
+void lldb_private::DumpProcessInstanceTableHeader(Stream &s, Platform *platform,
+                                                  bool show_args,
+                                                  bool verbose) {
   const char *label;
   if (show_args || verbose)
     label = "ARGUMENTS";
   else
     label = "NAME";
 
   if (verbose) {
     s.Printf("PID    PARENT USER       GROUP      EFF USER   EFF GROUP  TRIPLE "
              "                  %s\n",
              label);
     s.PutCString("====== ====== ========== ========== ========== ========== "
                  "======================== ============================\n");
   } else {
     s.Printf("PID    PARENT USER       TRIPLE                   %s\n", label);
     s.PutCString("====== ====== ========== ======================== "
                  "============================\n");
   }
 }
 
-void ProcessInstanceInfo::DumpAsTableRow(Stream &s, Platform *platform,
-                                         bool show_args, bool verbose) const {
-  if (m_pid != LLDB_INVALID_PROCESS_ID) {
+void lldb_private::DumpProcessInstanceAsTableRow(
+    Stream &s, const ProcessInstanceInfo &proc, Platform *platform,
+    bool show_args, bool verbose) {
+  if (proc.GetProcessID() != LLDB_INVALID_PROCESS_ID) {
     const char *cstr;
-    s.Printf("%-6" PRIu64 " %-6" PRIu64 " ", m_pid, m_parent_pid);
+    s.Printf("%-6" PRIu64 " %-6" PRIu64 " ", proc.GetProcessID(),
+             proc.GetParentProcessID());
 
     StreamString arch_strm;
-    if (m_arch.IsValid())
-      m_arch.DumpTriple(arch_strm);
+    if (proc.GetArchitecture().IsValid())
+      proc.GetArchitecture().DumpTriple(arch_strm);
 
     if (verbose) {
-      cstr = platform->GetUserName(m_uid);
+      cstr = platform->GetUserName(proc.GetUserID());
       if (cstr &&
           cstr[0]) // Watch for empty string that indicates lookup failed
         s.Printf("%-10s ", cstr);
       else
-        s.Printf("%-10u ", m_uid);
+        s.Printf("%-10u ", proc.GetUserID());
 
-      cstr = platform->GetGroupName(m_gid);
+      cstr = platform->GetGroupName(proc.GetGroupID());
       if (cstr &&
           cstr[0]) // Watch for empty string that indicates lookup failed
         s.Printf("%-10s ", cstr);
       else
-        s.Printf("%-10u ", m_gid);
+        s.Printf("%-10u ", proc.GetGroupID());
 
-      cstr = platform->GetUserName(m_euid);
+      cstr = platform->GetUserName(proc.GetEffectiveUserID());
       if (cstr &&
           cstr[0]) // Watch for empty string that indicates lookup failed
         s.Printf("%-10s ", cstr);
       else
-        s.Printf("%-10u ", m_euid);
+        s.Printf("%-10u ", proc.GetEffectiveUserID());
 
-      cstr = platform->GetGroupName(m_egid);
+      cstr = platform->GetGroupName(proc.GetEffectiveGroupID());
       if (cstr &&
           cstr[0]) // Watch for empty string that indicates lookup failed
         s.Printf("%-10s ", cstr);
       else
-        s.Printf("%-10u ", m_egid);
+        s.Printf("%-10u ", proc.GetEffectiveGroupID());
 
       s.Printf("%-24s ", arch_strm.GetData());
     } else {
-      s.Printf("%-10s %-24s ", platform->GetUserName(m_euid),
+      s.Printf("%-10s %-24s ", platform->GetUserName(proc.GetEffectiveUserID()),
                arch_strm.GetData());
     }
 
     if (verbose || show_args) {
-      const uint32_t argc = m_arguments.GetArgumentCount();
+      const uint32_t argc = proc.GetArguments().GetArgumentCount();
       if (argc > 0) {
         for (uint32_t i = 0; i < argc; i++) {
           if (i > 0)
             s.PutChar(' ');
-          s.PutCString(m_arguments.GetArgumentAtIndex(i));
+          s.PutCString(proc.GetArguments().GetArgumentAtIndex(i));
         }
       }
     } else {
-      s.PutCString(GetName());
+      s.PutCString(proc.GetName());
     }
 
     s.EOL();
   }
 }
 
 Status ProcessLaunchCommandOptions::SetOptionValue(
     uint32_t option_idx, llvm::StringRef option_arg,
static constexpr OptionDefinition g_process_launch_options[] = {
      OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeBoolean,
      "Set whether to shell expand arguments to the process when launching."},
 };
 
 llvm::ArrayRef<OptionDefinition> ProcessLaunchCommandOptions::GetDefinitions() {
   return llvm::makeArrayRef(g_process_launch_options);
 }
 
-bool ProcessInstanceInfoMatch::NameMatches(const char *process_name) const {
-  if (m_name_match_type == NameMatch::Ignore || process_name == nullptr)
-    return true;
-  const char *match_name = m_match_info.GetName();
-  if (!match_name)
-    return true;
-
-  return lldb_private::NameMatches(process_name, m_name_match_type, match_name);
-}
-
-bool ProcessInstanceInfoMatch::Matches(
-    const ProcessInstanceInfo &proc_info) const {
-  if (!NameMatches(proc_info.GetName()))
-    return false;
-
-  if (m_match_info.ProcessIDIsValid() &&
-      m_match_info.GetProcessID() != proc_info.GetProcessID())
-    return false;
-
-  if (m_match_info.ParentProcessIDIsValid() &&
-      m_match_info.GetParentProcessID() != proc_info.GetParentProcessID())
-    return false;
-
-  if (m_match_info.UserIDIsValid() &&
-      m_match_info.GetUserID() != proc_info.GetUserID())
-    return false;
-
-  if (m_match_info.GroupIDIsValid() &&
-      m_match_info.GetGroupID() != proc_info.GetGroupID())
-    return false;
-
-  if (m_match_info.EffectiveUserIDIsValid() &&
-      m_match_info.GetEffectiveUserID() != proc_info.GetEffectiveUserID())
-    return false;
-
-  if (m_match_info.EffectiveGroupIDIsValid() &&
-      m_match_info.GetEffectiveGroupID() != proc_info.GetEffectiveGroupID())
-    return false;
-
-  if (m_match_info.GetArchitecture().IsValid() &&
-      !m_match_info.GetArchitecture().IsCompatibleMatch(
-          proc_info.GetArchitecture()))
-    return false;
-  return true;
-}
-
-bool ProcessInstanceInfoMatch::MatchAllProcesses() const {
-  if (m_name_match_type != NameMatch::Ignore)
-    return false;
-
-  if (m_match_info.ProcessIDIsValid())
-    return false;
-
-  if (m_match_info.ParentProcessIDIsValid())
-    return false;
-
-  if (m_match_info.UserIDIsValid())
-    return false;
-
-  if (m_match_info.GroupIDIsValid())
-    return false;
-
-  if (m_match_info.EffectiveUserIDIsValid())
-    return false;
-
-  if (m_match_info.EffectiveGroupIDIsValid())
-    return false;
-
-  if (m_match_info.GetArchitecture().IsValid())
-    return false;
-
-  if (m_match_all_users)
-    return false;
-
-  return true;
-}
-
-void ProcessInstanceInfoMatch::Clear() {
-  m_match_info.Clear();
-  m_name_match_type = NameMatch::Ignore;
-  m_match_all_users = false;
-}
-
 ProcessSP Process::FindPlugin(lldb::TargetSP target_sp,
                               llvm::StringRef plugin_name,
                               ListenerSP listener_sp,
                               const FileSpec *crash_file_path) {
   static uint32_t g_process_unique_id = 0;
 
   ProcessSP process_sp;
   ProcessCreateInstance create_callback = nullptr;
if (attach_info.GetExecutableFile().GetPath(process_name,
           if (num_matches == 1) {
             attach_pid = process_infos.GetProcessIDAtIndex(0);
             // Fall through and attach using the above process ID
           } else {
             match_info.GetProcessInfo().GetExecutableFile().GetPath(
                 process_name, sizeof(process_name));
             if (num_matches > 1) {
               StreamString s;
-              ProcessInstanceInfo::DumpTableHeader(s, platform_sp.get(), true,
-                                                   false);
+              DumpProcessInstanceTableHeader(s, platform_sp.get(), true, false);
               for (size_t i = 0; i < num_matches; i++) {
-                process_infos.GetProcessInfoAtIndex(i).DumpAsTableRow(
-                    s, platform_sp.get(), true, false);
+                DumpProcessInstanceAsTableRow(
+                    s, process_infos.GetProcessInfoAtIndex(i),
+                    platform_sp.get(), true, false);
               }
               error.SetErrorStringWithFormat(
                   "more than one process named %s:\n%s", process_name,
                   s.GetData());
             } else
               error.SetErrorStringWithFormat(
                   "could not find a process named %s", process_name);
           }

lldb/source/Utility/CMakeLists.txt

add_lldb_library(lldbUtility
   FileSpec.cpp
   IOObject.cpp
   JSON.cpp
   LLDBAssert.cpp
   Listener.cpp
   Log.cpp
   Logging.cpp
   NameMatches.cpp
+  ProcessInfo.cpp
   RegisterValue.cpp
   RegularExpression.cpp
   Reproducer.cpp
   ReproducerInstrumentation.cpp
   Scalar.cpp
   SelectHelper.cpp
   SharingPtr.cpp
   State.cpp

lldb/source/Utility/ProcessInfo.cpp

-//===-- ProcessInfo.cpp -----------------------------------------*- C++ -*-===//
+//===-- ProcessInstance.cpp -------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "lldb/Host/ProcessInfo.h"
+#include "lldb/Utility/ProcessInfo.h"
 
-#include <climits>
-
-#include "lldb/Host/PosixApi.h"
+#include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/Stream.h"
-
 #include "llvm/ADT/SmallString.h"
 
+#include <climits>
+
 using namespace lldb;
 using namespace lldb_private;
 
 ProcessInfo::ProcessInfo()
     : m_executable(), m_arguments(), m_environment(), m_uid(UINT32_MAX),
       m_gid(UINT32_MAX), m_arch(), m_pid(LLDB_INVALID_PROCESS_ID) {}
 
 ProcessInfo::ProcessInfo(const char *name, const ArchSpec &arch,
if (add_exe_file_as_first_arg) {
       if (!filename.empty())
         m_arguments.InsertArgumentAtIndex(0, filename);
     }
   } else {
     m_executable.Clear();
   }
 }
 
-llvm::StringRef ProcessInfo::GetArg0() const {
-  return m_arg0;
-}
+llvm::StringRef ProcessInfo::GetArg0() const { return m_arg0; }
 
-void ProcessInfo::SetArg0(llvm::StringRef arg) {
-  m_arg0 = arg;
-}
+void ProcessInfo::SetArg0(llvm::StringRef arg) { m_arg0 = arg; }
 
 void ProcessInfo::SetArguments(char const **argv,
                                bool first_arg_is_executable) {
   m_arguments.SetArguments(argv);
 
   // Is the first argument the executable?
   if (first_arg_is_executable) {
     const char *first_arg = m_arguments.GetArgumentAtIndex(0);
if (first_arg_is_executable) {
     if (first_arg) {
       // Yes the first argument is an executable, set it as the executable in
       // the launch options. Don't resolve the file path as the path could be a
       // remote platform path
       m_executable.SetFile(first_arg, FileSpec::Style::native);
     }
   }
 }
+
+bool ProcessInstanceInfoMatch::NameMatches(const char *process_name) const {
+  if (m_name_match_type == NameMatch::Ignore || process_name == nullptr)
+    return true;
+  const char *match_name = m_match_info.GetName();
+  if (!match_name)
+    return true;
+
+  return lldb_private::NameMatches(process_name, m_name_match_type, match_name);
+}
+
+bool ProcessInstanceInfoMatch::Matches(
+    const ProcessInstanceInfo &proc_info) const {
+  if (!NameMatches(proc_info.GetName()))
+    return false;
+
+  if (m_match_info.ProcessIDIsValid() &&
+      m_match_info.GetProcessID() != proc_info.GetProcessID())
+    return false;
+
+  if (m_match_info.ParentProcessIDIsValid() &&
+      m_match_info.GetParentProcessID() != proc_info.GetParentProcessID())
+    return false;
+
+  if (m_match_info.UserIDIsValid() &&
+      m_match_info.GetUserID() != proc_info.GetUserID())
+    return false;
+
+  if (m_match_info.GroupIDIsValid() &&
+      m_match_info.GetGroupID() != proc_info.GetGroupID())
+    return false;
+
+  if (m_match_info.EffectiveUserIDIsValid() &&
+      m_match_info.GetEffectiveUserID() != proc_info.GetEffectiveUserID())
+    return false;
+
+  if (m_match_info.EffectiveGroupIDIsValid() &&
+      m_match_info.GetEffectiveGroupID() != proc_info.GetEffectiveGroupID())
+    return false;
+
+  if (m_match_info.GetArchitecture().IsValid() &&
+      !m_match_info.GetArchitecture().IsCompatibleMatch(
+          proc_info.GetArchitecture()))
+    return false;
+  return true;
+}
+
+bool ProcessInstanceInfoMatch::MatchAllProcesses() const {
+  if (m_name_match_type != NameMatch::Ignore)
+    return false;
+
+  if (m_match_info.ProcessIDIsValid())
+    return false;
+
+  if (m_match_info.ParentProcessIDIsValid())
+    return false;
+
+  if (m_match_info.UserIDIsValid())
+    return false;
+
+  if (m_match_info.GroupIDIsValid())
+    return false;
+
+  if (m_match_info.EffectiveUserIDIsValid())
+    return false;
+
+  if (m_match_info.EffectiveGroupIDIsValid())
+    return false;
+
+  if (m_match_info.GetArchitecture().IsValid())
+    return false;
+
+  if (m_match_all_users)
+    return false;
+
+  return true;
+}
+
+void ProcessInstanceInfoMatch::Clear() {
+  m_match_info.Clear();
+  m_name_match_type = NameMatch::Ignore;
+  m_match_all_users = false;
+}

lldb/unittests/Host/CMakeLists.txt

 set (FILES
   FileActionTest.cpp
   FileSystemTest.cpp
   HostInfoTest.cpp
   HostTest.cpp
   MainLoopTest.cpp
   NativeProcessProtocolTest.cpp
-  ProcessInfoTest.cpp
   ProcessLaunchInfoTest.cpp
   SocketAddressTest.cpp
   SocketTest.cpp
   TaskPoolTest.cpp
 )
 
 if (CMAKE_SYSTEM_NAME MATCHES "Linux|Android")
   list(APPEND FILES

lldb/unittests/Utility/CMakeLists.txt

add_lldb_unittest(UtilityTests
   FileCollectorTest.cpp
   FileSpecTest.cpp
   FlagsTest.cpp
   JSONTest.cpp
   ListenerTest.cpp
   LogTest.cpp
   NameMatchesTest.cpp
   PredicateTest.cpp
+  ProcessInfoTest.cpp
   RegisterValueTest.cpp
   ReproducerTest.cpp
   ReproducerInstrumentationTest.cpp
   ScalarTest.cpp
   StateTest.cpp
   StatusTest.cpp
   StreamTeeTest.cpp
   StreamTest.cpp

lldb/unittests/Utility/ProcessInfoTest.cpp

 //===-- ProcessInfoTest.cpp -------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "lldb/Host/ProcessInfo.h"
+#include "lldb/Utility/ProcessInfo.h"
 #include "gtest/gtest.h"
 
 using namespace lldb_private;
 
 TEST(ProcessInfoTest, Constructor) {
   ProcessInfo Info("foo", ArchSpec("x86_64-pc-linux"), 47);
   EXPECT_STREQ("foo", Info.GetName());
   EXPECT_EQ(ArchSpec("x86_64-pc-linux"), Info.GetArchitecture());
   EXPECT_EQ(47u, Info.GetProcessID());
 }