[LLDB/API] Expose args and env from SBProcessInfo.

[brucem]

Summary

This is another step towards implementing the equivalent of
platform process list and related functionality.

uint32_t is used for the argument count and index despite the
underlying value being size_t to be consistent with other
index-based access to arguments.

[mib]

LGTM!

[teemperor]

lldb/bindings/interface/SBProcessInfo.i

78

Can you add this line here?

%feature("autodoc", "GetArgumentAtIndex(int index) -> string") GetArgumentAtIndex;

Otherwise the Python docs will mention that this returns const char * which is always kinda weird for users to see.

[brucem]

Rebase and address feedback.

[brucem]

lldb/bindings/interface/SBProcessInfo.i

78

I changed this to have the whole thing be an autodoc rather than both an autodoc and a docstring. This isn't consistently done throughout the code though and in this case, the resulting syntax help is a bit different.

[brucem]

Not sure why this failed. Is it perhaps a difference where some processes have args including the executable and some do not?

[teemperor]

In D103675#2800653, @brucem wrote:

Not sure why this failed. Is it perhaps a difference where some processes have args including the executable and some do not?

Do you have the bot failures around for that? (Or, the platform at least so I could reproduce it locally?)

lldb/bindings/interface/SBProcessInfo.i

78

Sure, let's see how it looks on the website and then we can decide what works.

[brucem]

It failed because on macOS, the underlying args contains argv0 while on Linux it does not. So my test that checked that GetNumArguments is 1 fails on macOS, since there are 2.

Ideally, each platform would agree on whether or not the argv0 was included in the args ... or I can modify the test to check that the last argument is --abc.

(I've just been busy this week, so I hadn't gotten back to this.)

lldb/bindings/interface/SBProcessInfo.i

public:
     lldb::pid_t
     GetParentProcessID ();
 
     %feature("docstring",
     "Return the target triple (arch-vendor-os) for the described process."
     ) GetTriple;
     const char *
     GetTriple ();
+
+    %feature("docstring",
+    "Return the number of arguments given to the described process."
+    ) GetNumArguments;
+    uint32_t
+    GetNumArguments ();
+
+    %feature("autodoc", "
+    GetArgumentAtIndex(int index) -> string
+    Return the specified argument given to the described process."
+    ) GetArgumentAtIndex;
+    const char *
+    GetArgumentAtIndex (uint32_t index);
+
+    %feature("docstring",
+    "Return the environment variables for the described process."
+    ) GetEnvironment;
+    SBEnvironment
+    GetEnvironment ();
 };
 
 } // namespace lldb

lldb/include/lldb/API/SBEnvironment.h

 //===-- SBEnvironment.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_API_SBENVIRONMENT_H
 #define LLDB_API_SBENVIRONMENT_H
 
 #include "lldb/API/SBDefines.h"
 
 namespace lldb {
 
 class LLDB_API SBEnvironment {
 public:
   SBEnvironment();
 
   SBEnvironment(const lldb::SBEnvironment &rhs);
public:
   bool Unset(const char *name);
 
   /// Delete all the environment variables.
   void Clear();
 
 protected:
   friend class SBPlatform;
   friend class SBTarget;
+  friend class SBProcessInfo;
   friend class SBLaunchInfo;
 
   SBEnvironment(lldb_private::Environment rhs);
 
   lldb_private::Environment &ref() const;
 
 private:
   std::unique_ptr<lldb_private::Environment> m_opaque_up;
 };
 
 } // namespace lldb
 
 #endif // LLDB_API_SBENVIRONMENT_H

lldb/include/lldb/API/SBProcessInfo.h

 //===-- SBProcessInfo.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_API_SBPROCESSINFO_H
 #define LLDB_API_SBPROCESSINFO_H
 
 #include "lldb/API/SBDefines.h"
 
 namespace lldb {
 
 class LLDB_API SBProcessInfo {
 public:
   SBProcessInfo();
   SBProcessInfo(const SBProcessInfo &rhs);
 
public:
 
   bool EffectiveGroupIDIsValid();
 
   lldb::pid_t GetParentProcessID();
 
   /// Return the target triple (arch-vendor-os) for the described process.
   const char *GetTriple();
 
+  // Return the number of arguments given to the described process.
+  uint32_t GetNumArguments();
+
+  // Return the specified argument given to the described process.
+  const char *GetArgumentAtIndex(uint32_t index);
+
+  /// Return the environment variables for the described process.
+  ///
+  /// \return
+  ///     An lldb::SBEnvironment object which is a copy of the process
+  ///     environment.
+  SBEnvironment GetEnvironment();
+
 private:
   friend class SBProcess;
 
   lldb_private::ProcessInstanceInfo &ref();
 
   void SetProcessInfo(const lldb_private::ProcessInstanceInfo &proc_info_ref);
 
   std::unique_ptr<lldb_private::ProcessInstanceInfo> m_opaque_up;
 };
 
 } // namespace lldb
 
 #endif // LLDB_API_SBPROCESSINFO_H

lldb/source/API/SBProcessInfo.cpp

 //===-- SBProcessInfo.cpp -------------------------------------------------===//
 //
 // 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 "SBReproducerPrivate.h"
 #include "Utils.h"
+#include "lldb/API/SBEnvironment.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/Utility/ProcessInfo.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBProcessInfo::SBProcessInfo() : m_opaque_up() {
   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBProcessInfo);
if (arch.IsValid()) {
       // Const-ify the string so we don't need to worry about the lifetime of
       // the string
       triple = ConstString(arch.GetTriple().getTriple().c_str()).GetCString();
     }
   }
   return triple;
 }
 
+uint32_t SBProcessInfo::GetNumArguments() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetNumArguments);
+
+  uint32_t num = 0;
+  if (m_opaque_up) {
+    num = m_opaque_up->GetArguments().size();
+  }
+  return num;
+}
+
+const char *SBProcessInfo::GetArgumentAtIndex(uint32_t index) {
+  LLDB_RECORD_METHOD(const char *, SBProcessInfo, GetArgumentAtIndex,
+                     (uint32_t), index);
+
+  const char *argument = nullptr;
+  if (m_opaque_up) {
+    argument = m_opaque_up->GetArguments().GetArgumentAtIndex(index);
+  }
+  return argument;
+}
+
+SBEnvironment SBProcessInfo::GetEnvironment() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBEnvironment, SBProcessInfo,
+                             GetEnvironment);
+
+  if (m_opaque_up) {
+    return LLDB_RECORD_RESULT(SBEnvironment(m_opaque_up->GetEnvironment()));
+  }
+
+  return LLDB_RECORD_RESULT(SBEnvironment());
+}
+
 namespace lldb_private {
 namespace repro {
 
 template <>
 void RegisterMethods<SBProcessInfo>(Registry &R) {
   LLDB_REGISTER_CONSTRUCTOR(SBProcessInfo, ());
   LLDB_REGISTER_CONSTRUCTOR(SBProcessInfo, (const lldb::SBProcessInfo &));
   LLDB_REGISTER_METHOD(
void RegisterMethods<SBProcessInfo>(Registry &R) {
   LLDB_REGISTER_METHOD(bool, SBProcessInfo, UserIDIsValid, ());
   LLDB_REGISTER_METHOD(bool, SBProcessInfo, GroupIDIsValid, ());
   LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetEffectiveUserID, ());
   LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetEffectiveGroupID, ());
   LLDB_REGISTER_METHOD(bool, SBProcessInfo, EffectiveUserIDIsValid, ());
   LLDB_REGISTER_METHOD(bool, SBProcessInfo, EffectiveGroupIDIsValid, ());
   LLDB_REGISTER_METHOD(lldb::pid_t, SBProcessInfo, GetParentProcessID, ());
   LLDB_REGISTER_METHOD(const char *, SBProcessInfo, GetTriple, ());
+  LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetNumArguments, ());
+  LLDB_REGISTER_METHOD(const char *, SBProcessInfo, GetArgumentAtIndex,
+                       (uint32_t));
+  LLDB_REGISTER_METHOD(lldb::SBEnvironment, SBProcessInfo, GetEnvironment, ());
 }
 
 }
 }

lldb/test/API/python_api/process/TestProcessAPI.py

def test_get_process_info(self):
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # Launch the process and stop at the entry point.
         launch_info = target.GetLaunchInfo()
         launch_info.SetWorkingDirectory(self.get_process_working_directory())
+        launch_info.SetEnvironmentEntries(["FOO=BAR"], False)
+        launch_info.SetArguments(["--abc"], False)
         launch_flags = launch_info.GetLaunchFlags()
         launch_flags |= lldb.eLaunchFlagStopAtEntry
         launch_info.SetLaunchFlags(launch_flags)
         error = lldb.SBError()
         process = target.Launch(launch_info, error)
 
         if not error.Success():
             self.fail("Failed to launch process")
 
         # Verify basic process info can be retrieved successfully
         process_info = process.GetProcessInfo()
         self.assertTrue(process_info.IsValid())
         file_spec = process_info.GetExecutableFile()
         self.assertTrue(file_spec.IsValid())
         process_name = process_info.GetName()
         self.assertIsNotNone(process_name, "Process has a name")
         self.assertGreater(len(process_name), 0, "Process name isn't blank")
         self.assertEqual(file_spec.GetFilename(), "a.out")
         self.assertNotEqual(
             process_info.GetProcessID(), lldb.LLDB_INVALID_PROCESS_ID,
             "Process ID is valid")
         triple = process_info.GetTriple()
         self.assertIsNotNone(triple, "Process has a triple")
+        env = process_info.GetEnvironment()
+        self.assertGreater(env.GetNumValues(), 0)
+        self.assertEqual("BAR", env.Get("FOO"))
+        self.assertEqual(process_info.GetNumArguments(), 1)
+        self.assertEqual("--abc", process_info.GetArgumentAtIndex(0))
 
         # Additional process info varies by platform, so just check that
         # whatever info was retrieved is consistent and nothing blows up.
         if process_info.UserIDIsValid():
             self.assertNotEqual(
                 process_info.GetUserID(), lldb.UINT32_MAX,
                 "Process user ID is valid")
         else: