[lldb/API] Expose triple for SBProcessInfo.

[brucem]

Summary

This is present when doing a platform process list and is
tracked by the underlying code. To do something like the
process list via the SB API in the future, this must be
exposed.

[teemperor]

lldb/source/API/SBProcessInfo.cpp

191

You need to 'instrument' these functions. there is a tool called lldb-instr you can build withint LLDB and you can run that over the file to generate the macro stuff for you.

[brucem]

lldb/source/API/SBProcessInfo.cpp

191

This has the LLDB_RECORD_METHOD_NO_ARGS already and is the same as the other methods in this file. (And it calls LLDB_REGISTER_METHOD as well...)

[teemperor]

lldb/source/API/SBProcessInfo.cpp

191

My bad, I thought that we needed to put const char * inside a LLDB_RECORD_RESULT but apparently that's not the case (at least lldb-instr says it's not the case).

[clayborg]

LGTM

lldb/bindings/interface/SBProcessInfo.i

public:
     bool
     EffectiveUserIDIsValid ();
 
     bool
     EffectiveGroupIDIsValid ();
 
     lldb::pid_t
     GetParentProcessID ();
+
+    %feature("docstring",
+    "Return the target triple (arch-vendor-os) for the described process."
+    ) GetTriple;
+    const char *
+    GetTriple ();
 };
 
 } // namespace lldb

lldb/include/lldb/API/SBProcessInfo.h

public:
   uint32_t GetEffectiveGroupID();
 
   bool EffectiveUserIDIsValid();
 
   bool EffectiveGroupIDIsValid();
 
   lldb::pid_t GetParentProcessID();
 
+  /// Return the target triple (arch-vendor-os) for the described process.
+  const char *GetTriple();
+
 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

lldb::pid_t SBProcessInfo::GetParentProcessID() {
 
   lldb::pid_t proc_id = LLDB_INVALID_PROCESS_ID;
   if (m_opaque_up) {
     proc_id = m_opaque_up->GetParentProcessID();
   }
   return proc_id;
 }
 
+const char *SBProcessInfo::GetTriple() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcessInfo, GetTriple);
+
+  const char *triple = nullptr;
+  if (m_opaque_up) {
+    const auto &arch = m_opaque_up->GetArchitecture();
+    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;
+}
+
 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(uint32_t, SBProcessInfo, GetGroupID, ());
   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/test/API/python_api/process/TestProcessAPI.py

def test_get_process_info(self):
         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")
 
         # 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: