1 files changed, 112 insertions, 47 deletions

diff --git a/source/API/SBProcessInfo.cpp b/source/API/SBProcessInfo.cpp
index 2b3ebfb2465f..be242ec5872d 100644
--- a/source/API/SBProcessInfo.cpp
+++ b/source/API/SBProcessInfo.cpp
@@ -1,145 +1,210 @@
 //===-- SBProcessInfo.cpp ---------------------------------------*- C++ -*-===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// 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/SBFileSpec.h"
-#include "lldb/Target/Process.h"
+#include "lldb/Utility/ProcessInfo.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-SBProcessInfo::SBProcessInfo() : m_opaque_ap() {}
+SBProcessInfo::SBProcessInfo() : m_opaque_up() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBProcessInfo);
+}
 
-SBProcessInfo::SBProcessInfo(const SBProcessInfo &rhs) : m_opaque_ap() {
-  if (rhs.IsValid()) {
-    ref() = *rhs.m_opaque_ap;
-  }
+SBProcessInfo::SBProcessInfo(const SBProcessInfo &rhs) : m_opaque_up() {
+  LLDB_RECORD_CONSTRUCTOR(SBProcessInfo, (const lldb::SBProcessInfo &), rhs);
+
+  m_opaque_up = clone(rhs.m_opaque_up);
 }
 
 SBProcessInfo::~SBProcessInfo() {}
 
 SBProcessInfo &SBProcessInfo::operator=(const SBProcessInfo &rhs) {
-  if (this != &rhs) {
-    if (rhs.IsValid())
-      ref() = *rhs.m_opaque_ap;
-    else
-      m_opaque_ap.reset();
-  }
-  return *this;
+  LLDB_RECORD_METHOD(lldb::SBProcessInfo &,
+                     SBProcessInfo, operator=,(const lldb::SBProcessInfo &),
+                     rhs);
+
+  if (this != &rhs)
+    m_opaque_up = clone(rhs.m_opaque_up);
+  return LLDB_RECORD_RESULT(*this);
 }
 
 ProcessInstanceInfo &SBProcessInfo::ref() {
-  if (m_opaque_ap == nullptr) {
-    m_opaque_ap.reset(new ProcessInstanceInfo());
+  if (m_opaque_up == nullptr) {
+    m_opaque_up.reset(new ProcessInstanceInfo());
   }
-  return *m_opaque_ap;
+  return *m_opaque_up;
 }
 
 void SBProcessInfo::SetProcessInfo(const ProcessInstanceInfo &proc_info_ref) {
   ref() = proc_info_ref;
 }
 
-bool SBProcessInfo::IsValid() const { return m_opaque_ap != nullptr; }
+bool SBProcessInfo::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcessInfo, IsValid);
+  return this->operator bool();
+}
+SBProcessInfo::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcessInfo, operator bool);
+
+  return m_opaque_up != nullptr;
+}
 
 const char *SBProcessInfo::GetName() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcessInfo, GetName);
+
   const char *name = nullptr;
-  if (m_opaque_ap) {
-    name = m_opaque_ap->GetName();
+  if (m_opaque_up) {
+    name = m_opaque_up->GetName();
   }
   return name;
 }
 
 SBFileSpec SBProcessInfo::GetExecutableFile() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBProcessInfo,
+                             GetExecutableFile);
+
   SBFileSpec file_spec;
-  if (m_opaque_ap) {
-    file_spec.SetFileSpec(m_opaque_ap->GetExecutableFile());
+  if (m_opaque_up) {
+    file_spec.SetFileSpec(m_opaque_up->GetExecutableFile());
   }
-  return file_spec;
+  return LLDB_RECORD_RESULT(file_spec);
 }
 
 lldb::pid_t SBProcessInfo::GetProcessID() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBProcessInfo, GetProcessID);
+
   lldb::pid_t proc_id = LLDB_INVALID_PROCESS_ID;
-  if (m_opaque_ap) {
-    proc_id = m_opaque_ap->GetProcessID();
+  if (m_opaque_up) {
+    proc_id = m_opaque_up->GetProcessID();
   }
   return proc_id;
 }
 
 uint32_t SBProcessInfo::GetUserID() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetUserID);
+
   uint32_t user_id = UINT32_MAX;
-  if (m_opaque_ap) {
-    user_id = m_opaque_ap->GetUserID();
+  if (m_opaque_up) {
+    user_id = m_opaque_up->GetUserID();
   }
   return user_id;
 }
 
 uint32_t SBProcessInfo::GetGroupID() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetGroupID);
+
   uint32_t group_id = UINT32_MAX;
-  if (m_opaque_ap) {
-    group_id = m_opaque_ap->GetGroupID();
+  if (m_opaque_up) {
+    group_id = m_opaque_up->GetGroupID();
   }
   return group_id;
 }
 
 bool SBProcessInfo::UserIDIsValid() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, UserIDIsValid);
+
   bool is_valid = false;
-  if (m_opaque_ap) {
-    is_valid = m_opaque_ap->UserIDIsValid();
+  if (m_opaque_up) {
+    is_valid = m_opaque_up->UserIDIsValid();
   }
   return is_valid;
 }
 
 bool SBProcessInfo::GroupIDIsValid() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, GroupIDIsValid);
+
   bool is_valid = false;
-  if (m_opaque_ap) {
-    is_valid = m_opaque_ap->GroupIDIsValid();
+  if (m_opaque_up) {
+    is_valid = m_opaque_up->GroupIDIsValid();
   }
   return is_valid;
 }
 
 uint32_t SBProcessInfo::GetEffectiveUserID() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetEffectiveUserID);
+
   uint32_t user_id = UINT32_MAX;
-  if (m_opaque_ap) {
-    user_id = m_opaque_ap->GetEffectiveUserID();
+  if (m_opaque_up) {
+    user_id = m_opaque_up->GetEffectiveUserID();
   }
   return user_id;
 }
 
 uint32_t SBProcessInfo::GetEffectiveGroupID() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetEffectiveGroupID);
+
   uint32_t group_id = UINT32_MAX;
-  if (m_opaque_ap) {
-    group_id = m_opaque_ap->GetEffectiveGroupID();
+  if (m_opaque_up) {
+    group_id = m_opaque_up->GetEffectiveGroupID();
   }
   return group_id;
 }
 
 bool SBProcessInfo::EffectiveUserIDIsValid() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, EffectiveUserIDIsValid);
+
   bool is_valid = false;
-  if (m_opaque_ap) {
-    is_valid = m_opaque_ap->EffectiveUserIDIsValid();
+  if (m_opaque_up) {
+    is_valid = m_opaque_up->EffectiveUserIDIsValid();
   }
   return is_valid;
 }
 
 bool SBProcessInfo::EffectiveGroupIDIsValid() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, EffectiveGroupIDIsValid);
+
   bool is_valid = false;
-  if (m_opaque_ap) {
-    is_valid = m_opaque_ap->EffectiveGroupIDIsValid();
+  if (m_opaque_up) {
+    is_valid = m_opaque_up->EffectiveGroupIDIsValid();
   }
   return is_valid;
 }
 
 lldb::pid_t SBProcessInfo::GetParentProcessID() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBProcessInfo, GetParentProcessID);
+
   lldb::pid_t proc_id = LLDB_INVALID_PROCESS_ID;
-  if (m_opaque_ap) {
-    proc_id = m_opaque_ap->GetParentProcessID();
+  if (m_opaque_up) {
+    proc_id = m_opaque_up->GetParentProcessID();
   }
   return proc_id;
 }
+
+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(
+      lldb::SBProcessInfo &,
+      SBProcessInfo, operator=,(const lldb::SBProcessInfo &));
+  LLDB_REGISTER_METHOD_CONST(bool, SBProcessInfo, IsValid, ());
+  LLDB_REGISTER_METHOD_CONST(bool, SBProcessInfo, operator bool, ());
+  LLDB_REGISTER_METHOD(const char *, SBProcessInfo, GetName, ());
+  LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBProcessInfo, GetExecutableFile,
+                       ());
+  LLDB_REGISTER_METHOD(lldb::pid_t, SBProcessInfo, GetProcessID, ());
+  LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetUserID, ());
+  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, ());
+}
+
+}
+}