summaryrefslogtreecommitdiff
path: root/source/API/SBAttachInfo.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'source/API/SBAttachInfo.cpp')
-rw-r--r--source/API/SBAttachInfo.cpp175
1 files changed, 158 insertions, 17 deletions
diff --git a/source/API/SBAttachInfo.cpp b/source/API/SBAttachInfo.cpp
index a74487a70fe3..838385c104ae 100644
--- a/source/API/SBAttachInfo.cpp
+++ b/source/API/SBAttachInfo.cpp
@@ -1,14 +1,14 @@
//===-- SBAttachInfo.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/SBAttachInfo.h"
-
+#include "SBReproducerPrivate.h"
+#include "Utils.h"
#include "lldb/API/SBFileSpec.h"
#include "lldb/API/SBListener.h"
#include "lldb/Target/Process.h"
@@ -16,15 +16,21 @@
using namespace lldb;
using namespace lldb_private;
-SBAttachInfo::SBAttachInfo() : m_opaque_sp(new ProcessAttachInfo()) {}
+SBAttachInfo::SBAttachInfo() : m_opaque_sp(new ProcessAttachInfo()) {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBAttachInfo);
+}
SBAttachInfo::SBAttachInfo(lldb::pid_t pid)
: m_opaque_sp(new ProcessAttachInfo()) {
+ LLDB_RECORD_CONSTRUCTOR(SBAttachInfo, (lldb::pid_t), pid);
+
m_opaque_sp->SetProcessID(pid);
}
SBAttachInfo::SBAttachInfo(const char *path, bool wait_for)
: m_opaque_sp(new ProcessAttachInfo()) {
+ LLDB_RECORD_CONSTRUCTOR(SBAttachInfo, (const char *, bool), path, wait_for);
+
if (path && path[0])
m_opaque_sp->GetExecutableFile().SetFile(path, FileSpec::Style::native);
m_opaque_sp->SetWaitForLaunch(wait_for);
@@ -32,6 +38,9 @@ SBAttachInfo::SBAttachInfo(const char *path, bool wait_for)
SBAttachInfo::SBAttachInfo(const char *path, bool wait_for, bool async)
: m_opaque_sp(new ProcessAttachInfo()) {
+ LLDB_RECORD_CONSTRUCTOR(SBAttachInfo, (const char *, bool, bool), path,
+ wait_for, async);
+
if (path && path[0])
m_opaque_sp->GetExecutableFile().SetFile(path, FileSpec::Style::native);
m_opaque_sp->SetWaitForLaunch(wait_for);
@@ -40,7 +49,9 @@ SBAttachInfo::SBAttachInfo(const char *path, bool wait_for, bool async)
SBAttachInfo::SBAttachInfo(const SBAttachInfo &rhs)
: m_opaque_sp(new ProcessAttachInfo()) {
- *m_opaque_sp = *rhs.m_opaque_sp;
+ LLDB_RECORD_CONSTRUCTOR(SBAttachInfo, (const lldb::SBAttachInfo &), rhs);
+
+ m_opaque_sp = clone(rhs.m_opaque_sp);
}
SBAttachInfo::~SBAttachInfo() {}
@@ -48,34 +59,54 @@ SBAttachInfo::~SBAttachInfo() {}
lldb_private::ProcessAttachInfo &SBAttachInfo::ref() { return *m_opaque_sp; }
SBAttachInfo &SBAttachInfo::operator=(const SBAttachInfo &rhs) {
+ LLDB_RECORD_METHOD(lldb::SBAttachInfo &,
+ SBAttachInfo, operator=,(const lldb::SBAttachInfo &), rhs);
+
if (this != &rhs)
- *m_opaque_sp = *rhs.m_opaque_sp;
- return *this;
+ m_opaque_sp = clone(rhs.m_opaque_sp);
+ return LLDB_RECORD_RESULT(*this);
}
-lldb::pid_t SBAttachInfo::GetProcessID() { return m_opaque_sp->GetProcessID(); }
+lldb::pid_t SBAttachInfo::GetProcessID() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBAttachInfo, GetProcessID);
+
+ return m_opaque_sp->GetProcessID();
+}
void SBAttachInfo::SetProcessID(lldb::pid_t pid) {
+ LLDB_RECORD_METHOD(void, SBAttachInfo, SetProcessID, (lldb::pid_t), pid);
+
m_opaque_sp->SetProcessID(pid);
}
uint32_t SBAttachInfo::GetResumeCount() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetResumeCount);
+
return m_opaque_sp->GetResumeCount();
}
void SBAttachInfo::SetResumeCount(uint32_t c) {
+ LLDB_RECORD_METHOD(void, SBAttachInfo, SetResumeCount, (uint32_t), c);
+
m_opaque_sp->SetResumeCount(c);
}
const char *SBAttachInfo::GetProcessPluginName() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBAttachInfo, GetProcessPluginName);
+
return m_opaque_sp->GetProcessPluginName();
}
void SBAttachInfo::SetProcessPluginName(const char *plugin_name) {
+ LLDB_RECORD_METHOD(void, SBAttachInfo, SetProcessPluginName, (const char *),
+ plugin_name);
+
return m_opaque_sp->SetProcessPluginName(plugin_name);
}
void SBAttachInfo::SetExecutable(const char *path) {
+ LLDB_RECORD_METHOD(void, SBAttachInfo, SetExecutable, (const char *), path);
+
if (path && path[0])
m_opaque_sp->GetExecutableFile().SetFile(path, FileSpec::Style::native);
else
@@ -83,6 +114,9 @@ void SBAttachInfo::SetExecutable(const char *path) {
}
void SBAttachInfo::SetExecutable(SBFileSpec exe_file) {
+ LLDB_RECORD_METHOD(void, SBAttachInfo, SetExecutable, (lldb::SBFileSpec),
+ exe_file);
+
if (exe_file.IsValid())
m_opaque_sp->GetExecutableFile() = exe_file.ref();
else
@@ -90,78 +124,185 @@ void SBAttachInfo::SetExecutable(SBFileSpec exe_file) {
}
bool SBAttachInfo::GetWaitForLaunch() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, GetWaitForLaunch);
+
return m_opaque_sp->GetWaitForLaunch();
}
void SBAttachInfo::SetWaitForLaunch(bool b) {
+ LLDB_RECORD_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool), b);
+
m_opaque_sp->SetWaitForLaunch(b);
}
void SBAttachInfo::SetWaitForLaunch(bool b, bool async) {
+ LLDB_RECORD_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool, bool), b,
+ async);
+
m_opaque_sp->SetWaitForLaunch(b);
m_opaque_sp->SetAsync(async);
}
bool SBAttachInfo::GetIgnoreExisting() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, GetIgnoreExisting);
+
return m_opaque_sp->GetIgnoreExisting();
}
void SBAttachInfo::SetIgnoreExisting(bool b) {
+ LLDB_RECORD_METHOD(void, SBAttachInfo, SetIgnoreExisting, (bool), b);
+
m_opaque_sp->SetIgnoreExisting(b);
}
-uint32_t SBAttachInfo::GetUserID() { return m_opaque_sp->GetUserID(); }
+uint32_t SBAttachInfo::GetUserID() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetUserID);
+
+ return m_opaque_sp->GetUserID();
+}
+
+uint32_t SBAttachInfo::GetGroupID() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetGroupID);
-uint32_t SBAttachInfo::GetGroupID() { return m_opaque_sp->GetGroupID(); }
+ return m_opaque_sp->GetGroupID();
+}
+
+bool SBAttachInfo::UserIDIsValid() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, UserIDIsValid);
-bool SBAttachInfo::UserIDIsValid() { return m_opaque_sp->UserIDIsValid(); }
+ return m_opaque_sp->UserIDIsValid();
+}
-bool SBAttachInfo::GroupIDIsValid() { return m_opaque_sp->GroupIDIsValid(); }
+bool SBAttachInfo::GroupIDIsValid() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, GroupIDIsValid);
-void SBAttachInfo::SetUserID(uint32_t uid) { m_opaque_sp->SetUserID(uid); }
+ return m_opaque_sp->GroupIDIsValid();
+}
+
+void SBAttachInfo::SetUserID(uint32_t uid) {
+ LLDB_RECORD_METHOD(void, SBAttachInfo, SetUserID, (uint32_t), uid);
+
+ m_opaque_sp->SetUserID(uid);
+}
-void SBAttachInfo::SetGroupID(uint32_t gid) { m_opaque_sp->SetGroupID(gid); }
+void SBAttachInfo::SetGroupID(uint32_t gid) {
+ LLDB_RECORD_METHOD(void, SBAttachInfo, SetGroupID, (uint32_t), gid);
+
+ m_opaque_sp->SetGroupID(gid);
+}
uint32_t SBAttachInfo::GetEffectiveUserID() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetEffectiveUserID);
+
return m_opaque_sp->GetEffectiveUserID();
}
uint32_t SBAttachInfo::GetEffectiveGroupID() {
+ LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetEffectiveGroupID);
+
return m_opaque_sp->GetEffectiveGroupID();
}
bool SBAttachInfo::EffectiveUserIDIsValid() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, EffectiveUserIDIsValid);
+
return m_opaque_sp->EffectiveUserIDIsValid();
}
bool SBAttachInfo::EffectiveGroupIDIsValid() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, EffectiveGroupIDIsValid);
+
return m_opaque_sp->EffectiveGroupIDIsValid();
}
void SBAttachInfo::SetEffectiveUserID(uint32_t uid) {
+ LLDB_RECORD_METHOD(void, SBAttachInfo, SetEffectiveUserID, (uint32_t), uid);
+
m_opaque_sp->SetEffectiveUserID(uid);
}
void SBAttachInfo::SetEffectiveGroupID(uint32_t gid) {
+ LLDB_RECORD_METHOD(void, SBAttachInfo, SetEffectiveGroupID, (uint32_t), gid);
+
m_opaque_sp->SetEffectiveGroupID(gid);
}
lldb::pid_t SBAttachInfo::GetParentProcessID() {
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBAttachInfo, GetParentProcessID);
+
return m_opaque_sp->GetParentProcessID();
}
void SBAttachInfo::SetParentProcessID(lldb::pid_t pid) {
+ LLDB_RECORD_METHOD(void, SBAttachInfo, SetParentProcessID, (lldb::pid_t),
+ pid);
+
m_opaque_sp->SetParentProcessID(pid);
}
bool SBAttachInfo::ParentProcessIDIsValid() {
+ LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, ParentProcessIDIsValid);
+
return m_opaque_sp->ParentProcessIDIsValid();
}
SBListener SBAttachInfo::GetListener() {
- return SBListener(m_opaque_sp->GetListener());
+ LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBAttachInfo, GetListener);
+
+ return LLDB_RECORD_RESULT(SBListener(m_opaque_sp->GetListener()));
}
void SBAttachInfo::SetListener(SBListener &listener) {
+ LLDB_RECORD_METHOD(void, SBAttachInfo, SetListener, (lldb::SBListener &),
+ listener);
+
m_opaque_sp->SetListener(listener.GetSP());
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBAttachInfo>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (lldb::pid_t));
+ LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (const char *, bool));
+ LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (const char *, bool, bool));
+ LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (const lldb::SBAttachInfo &));
+ LLDB_REGISTER_METHOD(lldb::SBAttachInfo &,
+ SBAttachInfo, operator=,(const lldb::SBAttachInfo &));
+ LLDB_REGISTER_METHOD(lldb::pid_t, SBAttachInfo, GetProcessID, ());
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetProcessID, (lldb::pid_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetResumeCount, ());
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetResumeCount, (uint32_t));
+ LLDB_REGISTER_METHOD(const char *, SBAttachInfo, GetProcessPluginName, ());
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetProcessPluginName,
+ (const char *));
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetExecutable, (const char *));
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetExecutable, (lldb::SBFileSpec));
+ LLDB_REGISTER_METHOD(bool, SBAttachInfo, GetWaitForLaunch, ());
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool));
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool, bool));
+ LLDB_REGISTER_METHOD(bool, SBAttachInfo, GetIgnoreExisting, ());
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetIgnoreExisting, (bool));
+ LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetUserID, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetGroupID, ());
+ LLDB_REGISTER_METHOD(bool, SBAttachInfo, UserIDIsValid, ());
+ LLDB_REGISTER_METHOD(bool, SBAttachInfo, GroupIDIsValid, ());
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetUserID, (uint32_t));
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetGroupID, (uint32_t));
+ LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetEffectiveUserID, ());
+ LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetEffectiveGroupID, ());
+ LLDB_REGISTER_METHOD(bool, SBAttachInfo, EffectiveUserIDIsValid, ());
+ LLDB_REGISTER_METHOD(bool, SBAttachInfo, EffectiveGroupIDIsValid, ());
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetEffectiveUserID, (uint32_t));
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetEffectiveGroupID, (uint32_t));
+ LLDB_REGISTER_METHOD(lldb::pid_t, SBAttachInfo, GetParentProcessID, ());
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetParentProcessID, (lldb::pid_t));
+ LLDB_REGISTER_METHOD(bool, SBAttachInfo, ParentProcessIDIsValid, ());
+ LLDB_REGISTER_METHOD(lldb::SBListener, SBAttachInfo, GetListener, ());
+ LLDB_REGISTER_METHOD(void, SBAttachInfo, SetListener, (lldb::SBListener &));
+}
+
+}
+}
generated by cgit v1.2.3 (git 2.25.1) at 2025-10-07 23:59:54 +0000