1//===-- SBAttachInfo.cpp ----------------------------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "lldb/API/SBAttachInfo.h"
10#include "SBReproducerPrivate.h"
11#include "Utils.h"
12#include "lldb/API/SBFileSpec.h"
13#include "lldb/API/SBListener.h"
14#include "lldb/Target/Process.h"
15
16using namespace lldb;
17using namespace lldb_private;
18
19SBAttachInfo::SBAttachInfo() : m_opaque_sp(new ProcessAttachInfo()) {
20  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBAttachInfo);
21}
22
23SBAttachInfo::SBAttachInfo(lldb::pid_t pid)
24    : m_opaque_sp(new ProcessAttachInfo()) {
25  LLDB_RECORD_CONSTRUCTOR(SBAttachInfo, (lldb::pid_t), pid);
26
27  m_opaque_sp->SetProcessID(pid);
28}
29
30SBAttachInfo::SBAttachInfo(const char *path, bool wait_for)
31    : m_opaque_sp(new ProcessAttachInfo()) {
32  LLDB_RECORD_CONSTRUCTOR(SBAttachInfo, (const char *, bool), path, wait_for);
33
34  if (path && path[0])
35    m_opaque_sp->GetExecutableFile().SetFile(path, FileSpec::Style::native);
36  m_opaque_sp->SetWaitForLaunch(wait_for);
37}
38
39SBAttachInfo::SBAttachInfo(const char *path, bool wait_for, bool async)
40    : m_opaque_sp(new ProcessAttachInfo()) {
41  LLDB_RECORD_CONSTRUCTOR(SBAttachInfo, (const char *, bool, bool), path,
42                          wait_for, async);
43
44  if (path && path[0])
45    m_opaque_sp->GetExecutableFile().SetFile(path, FileSpec::Style::native);
46  m_opaque_sp->SetWaitForLaunch(wait_for);
47  m_opaque_sp->SetAsync(async);
48}
49
50SBAttachInfo::SBAttachInfo(const SBAttachInfo &rhs)
51    : m_opaque_sp(new ProcessAttachInfo()) {
52  LLDB_RECORD_CONSTRUCTOR(SBAttachInfo, (const lldb::SBAttachInfo &), rhs);
53
54  m_opaque_sp = clone(rhs.m_opaque_sp);
55}
56
57SBAttachInfo::~SBAttachInfo() {}
58
59lldb_private::ProcessAttachInfo &SBAttachInfo::ref() { return *m_opaque_sp; }
60
61SBAttachInfo &SBAttachInfo::operator=(const SBAttachInfo &rhs) {
62  LLDB_RECORD_METHOD(lldb::SBAttachInfo &,
63                     SBAttachInfo, operator=,(const lldb::SBAttachInfo &), rhs);
64
65  if (this != &rhs)
66    m_opaque_sp = clone(rhs.m_opaque_sp);
67  return LLDB_RECORD_RESULT(*this);
68}
69
70lldb::pid_t SBAttachInfo::GetProcessID() {
71  LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBAttachInfo, GetProcessID);
72
73  return m_opaque_sp->GetProcessID();
74}
75
76void SBAttachInfo::SetProcessID(lldb::pid_t pid) {
77  LLDB_RECORD_METHOD(void, SBAttachInfo, SetProcessID, (lldb::pid_t), pid);
78
79  m_opaque_sp->SetProcessID(pid);
80}
81
82uint32_t SBAttachInfo::GetResumeCount() {
83  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetResumeCount);
84
85  return m_opaque_sp->GetResumeCount();
86}
87
88void SBAttachInfo::SetResumeCount(uint32_t c) {
89  LLDB_RECORD_METHOD(void, SBAttachInfo, SetResumeCount, (uint32_t), c);
90
91  m_opaque_sp->SetResumeCount(c);
92}
93
94const char *SBAttachInfo::GetProcessPluginName() {
95  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBAttachInfo, GetProcessPluginName);
96
97  return m_opaque_sp->GetProcessPluginName();
98}
99
100void SBAttachInfo::SetProcessPluginName(const char *plugin_name) {
101  LLDB_RECORD_METHOD(void, SBAttachInfo, SetProcessPluginName, (const char *),
102                     plugin_name);
103
104  return m_opaque_sp->SetProcessPluginName(plugin_name);
105}
106
107void SBAttachInfo::SetExecutable(const char *path) {
108  LLDB_RECORD_METHOD(void, SBAttachInfo, SetExecutable, (const char *), path);
109
110  if (path && path[0])
111    m_opaque_sp->GetExecutableFile().SetFile(path, FileSpec::Style::native);
112  else
113    m_opaque_sp->GetExecutableFile().Clear();
114}
115
116void SBAttachInfo::SetExecutable(SBFileSpec exe_file) {
117  LLDB_RECORD_METHOD(void, SBAttachInfo, SetExecutable, (lldb::SBFileSpec),
118                     exe_file);
119
120  if (exe_file.IsValid())
121    m_opaque_sp->GetExecutableFile() = exe_file.ref();
122  else
123    m_opaque_sp->GetExecutableFile().Clear();
124}
125
126bool SBAttachInfo::GetWaitForLaunch() {
127  LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, GetWaitForLaunch);
128
129  return m_opaque_sp->GetWaitForLaunch();
130}
131
132void SBAttachInfo::SetWaitForLaunch(bool b) {
133  LLDB_RECORD_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool), b);
134
135  m_opaque_sp->SetWaitForLaunch(b);
136}
137
138void SBAttachInfo::SetWaitForLaunch(bool b, bool async) {
139  LLDB_RECORD_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool, bool), b,
140                     async);
141
142  m_opaque_sp->SetWaitForLaunch(b);
143  m_opaque_sp->SetAsync(async);
144}
145
146bool SBAttachInfo::GetIgnoreExisting() {
147  LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, GetIgnoreExisting);
148
149  return m_opaque_sp->GetIgnoreExisting();
150}
151
152void SBAttachInfo::SetIgnoreExisting(bool b) {
153  LLDB_RECORD_METHOD(void, SBAttachInfo, SetIgnoreExisting, (bool), b);
154
155  m_opaque_sp->SetIgnoreExisting(b);
156}
157
158uint32_t SBAttachInfo::GetUserID() {
159  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetUserID);
160
161  return m_opaque_sp->GetUserID();
162}
163
164uint32_t SBAttachInfo::GetGroupID() {
165  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetGroupID);
166
167  return m_opaque_sp->GetGroupID();
168}
169
170bool SBAttachInfo::UserIDIsValid() {
171  LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, UserIDIsValid);
172
173  return m_opaque_sp->UserIDIsValid();
174}
175
176bool SBAttachInfo::GroupIDIsValid() {
177  LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, GroupIDIsValid);
178
179  return m_opaque_sp->GroupIDIsValid();
180}
181
182void SBAttachInfo::SetUserID(uint32_t uid) {
183  LLDB_RECORD_METHOD(void, SBAttachInfo, SetUserID, (uint32_t), uid);
184
185  m_opaque_sp->SetUserID(uid);
186}
187
188void SBAttachInfo::SetGroupID(uint32_t gid) {
189  LLDB_RECORD_METHOD(void, SBAttachInfo, SetGroupID, (uint32_t), gid);
190
191  m_opaque_sp->SetGroupID(gid);
192}
193
194uint32_t SBAttachInfo::GetEffectiveUserID() {
195  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetEffectiveUserID);
196
197  return m_opaque_sp->GetEffectiveUserID();
198}
199
200uint32_t SBAttachInfo::GetEffectiveGroupID() {
201  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetEffectiveGroupID);
202
203  return m_opaque_sp->GetEffectiveGroupID();
204}
205
206bool SBAttachInfo::EffectiveUserIDIsValid() {
207  LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, EffectiveUserIDIsValid);
208
209  return m_opaque_sp->EffectiveUserIDIsValid();
210}
211
212bool SBAttachInfo::EffectiveGroupIDIsValid() {
213  LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, EffectiveGroupIDIsValid);
214
215  return m_opaque_sp->EffectiveGroupIDIsValid();
216}
217
218void SBAttachInfo::SetEffectiveUserID(uint32_t uid) {
219  LLDB_RECORD_METHOD(void, SBAttachInfo, SetEffectiveUserID, (uint32_t), uid);
220
221  m_opaque_sp->SetEffectiveUserID(uid);
222}
223
224void SBAttachInfo::SetEffectiveGroupID(uint32_t gid) {
225  LLDB_RECORD_METHOD(void, SBAttachInfo, SetEffectiveGroupID, (uint32_t), gid);
226
227  m_opaque_sp->SetEffectiveGroupID(gid);
228}
229
230lldb::pid_t SBAttachInfo::GetParentProcessID() {
231  LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBAttachInfo, GetParentProcessID);
232
233  return m_opaque_sp->GetParentProcessID();
234}
235
236void SBAttachInfo::SetParentProcessID(lldb::pid_t pid) {
237  LLDB_RECORD_METHOD(void, SBAttachInfo, SetParentProcessID, (lldb::pid_t),
238                     pid);
239
240  m_opaque_sp->SetParentProcessID(pid);
241}
242
243bool SBAttachInfo::ParentProcessIDIsValid() {
244  LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, ParentProcessIDIsValid);
245
246  return m_opaque_sp->ParentProcessIDIsValid();
247}
248
249SBListener SBAttachInfo::GetListener() {
250  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBAttachInfo, GetListener);
251
252  return LLDB_RECORD_RESULT(SBListener(m_opaque_sp->GetListener()));
253}
254
255void SBAttachInfo::SetListener(SBListener &listener) {
256  LLDB_RECORD_METHOD(void, SBAttachInfo, SetListener, (lldb::SBListener &),
257                     listener);
258
259  m_opaque_sp->SetListener(listener.GetSP());
260}
261
262namespace lldb_private {
263namespace repro {
264
265template <>
266void RegisterMethods<SBAttachInfo>(Registry &R) {
267  LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, ());
268  LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (lldb::pid_t));
269  LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (const char *, bool));
270  LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (const char *, bool, bool));
271  LLDB_REGISTER_CONSTRUCTOR(SBAttachInfo, (const lldb::SBAttachInfo &));
272  LLDB_REGISTER_METHOD(lldb::SBAttachInfo &,
273                       SBAttachInfo, operator=,(const lldb::SBAttachInfo &));
274  LLDB_REGISTER_METHOD(lldb::pid_t, SBAttachInfo, GetProcessID, ());
275  LLDB_REGISTER_METHOD(void, SBAttachInfo, SetProcessID, (lldb::pid_t));
276  LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetResumeCount, ());
277  LLDB_REGISTER_METHOD(void, SBAttachInfo, SetResumeCount, (uint32_t));
278  LLDB_REGISTER_METHOD(const char *, SBAttachInfo, GetProcessPluginName, ());
279  LLDB_REGISTER_METHOD(void, SBAttachInfo, SetProcessPluginName,
280                       (const char *));
281  LLDB_REGISTER_METHOD(void, SBAttachInfo, SetExecutable, (const char *));
282  LLDB_REGISTER_METHOD(void, SBAttachInfo, SetExecutable, (lldb::SBFileSpec));
283  LLDB_REGISTER_METHOD(bool, SBAttachInfo, GetWaitForLaunch, ());
284  LLDB_REGISTER_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool));
285  LLDB_REGISTER_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool, bool));
286  LLDB_REGISTER_METHOD(bool, SBAttachInfo, GetIgnoreExisting, ());
287  LLDB_REGISTER_METHOD(void, SBAttachInfo, SetIgnoreExisting, (bool));
288  LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetUserID, ());
289  LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetGroupID, ());
290  LLDB_REGISTER_METHOD(bool, SBAttachInfo, UserIDIsValid, ());
291  LLDB_REGISTER_METHOD(bool, SBAttachInfo, GroupIDIsValid, ());
292  LLDB_REGISTER_METHOD(void, SBAttachInfo, SetUserID, (uint32_t));
293  LLDB_REGISTER_METHOD(void, SBAttachInfo, SetGroupID, (uint32_t));
294  LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetEffectiveUserID, ());
295  LLDB_REGISTER_METHOD(uint32_t, SBAttachInfo, GetEffectiveGroupID, ());
296  LLDB_REGISTER_METHOD(bool, SBAttachInfo, EffectiveUserIDIsValid, ());
297  LLDB_REGISTER_METHOD(bool, SBAttachInfo, EffectiveGroupIDIsValid, ());
298  LLDB_REGISTER_METHOD(void, SBAttachInfo, SetEffectiveUserID, (uint32_t));
299  LLDB_REGISTER_METHOD(void, SBAttachInfo, SetEffectiveGroupID, (uint32_t));
300  LLDB_REGISTER_METHOD(lldb::pid_t, SBAttachInfo, GetParentProcessID, ());
301  LLDB_REGISTER_METHOD(void, SBAttachInfo, SetParentProcessID, (lldb::pid_t));
302  LLDB_REGISTER_METHOD(bool, SBAttachInfo, ParentProcessIDIsValid, ());
303  LLDB_REGISTER_METHOD(lldb::SBListener, SBAttachInfo, GetListener, ());
304  LLDB_REGISTER_METHOD(void, SBAttachInfo, SetListener, (lldb::SBListener &));
305}
306
307}
308}
309