1 //===-- SBLaunchInfo.cpp --------------------------------------------------===//
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/SBLaunchInfo.h"
10 #include "SBReproducerPrivate.h"
11
12 #include "lldb/API/SBEnvironment.h"
13 #include "lldb/API/SBFileSpec.h"
14 #include "lldb/API/SBListener.h"
15 #include "lldb/Host/ProcessLaunchInfo.h"
16
17 using namespace lldb;
18 using namespace lldb_private;
19
20 class lldb_private::SBLaunchInfoImpl : public ProcessLaunchInfo {
21 public:
SBLaunchInfoImpl()22 SBLaunchInfoImpl()
23 : ProcessLaunchInfo(), m_envp(GetEnvironment().getEnvp()) {}
24
GetEnvp() const25 const char *const *GetEnvp() const { return m_envp; }
RegenerateEnvp()26 void RegenerateEnvp() { m_envp = GetEnvironment().getEnvp(); }
27
operator =(const ProcessLaunchInfo & rhs)28 SBLaunchInfoImpl &operator=(const ProcessLaunchInfo &rhs) {
29 ProcessLaunchInfo::operator=(rhs);
30 RegenerateEnvp();
31 return *this;
32 }
33
34 private:
35 Environment::Envp m_envp;
36 };
37
SBLaunchInfo(const char ** argv)38 SBLaunchInfo::SBLaunchInfo(const char **argv)
39 : m_opaque_sp(new SBLaunchInfoImpl()) {
40 LLDB_RECORD_CONSTRUCTOR(SBLaunchInfo, (const char **), argv);
41
42 m_opaque_sp->GetFlags().Reset(eLaunchFlagDebug | eLaunchFlagDisableASLR);
43 if (argv && argv[0])
44 m_opaque_sp->GetArguments().SetArguments(argv);
45 }
46
SBLaunchInfo(const SBLaunchInfo & rhs)47 SBLaunchInfo::SBLaunchInfo(const SBLaunchInfo &rhs) {
48 LLDB_RECORD_CONSTRUCTOR(SBLaunchInfo, (const lldb::SBLaunchInfo &), rhs);
49
50 m_opaque_sp = rhs.m_opaque_sp;
51 }
52
operator =(const SBLaunchInfo & rhs)53 SBLaunchInfo &SBLaunchInfo::operator=(const SBLaunchInfo &rhs) {
54 LLDB_RECORD_METHOD(SBLaunchInfo &,
55 SBLaunchInfo, operator=,(const lldb::SBLaunchInfo &), rhs);
56
57 m_opaque_sp = rhs.m_opaque_sp;
58 return LLDB_RECORD_RESULT(*this);
59 }
60
61 SBLaunchInfo::~SBLaunchInfo() = default;
62
ref() const63 const lldb_private::ProcessLaunchInfo &SBLaunchInfo::ref() const {
64 return *m_opaque_sp;
65 }
66
set_ref(const ProcessLaunchInfo & info)67 void SBLaunchInfo::set_ref(const ProcessLaunchInfo &info) {
68 *m_opaque_sp = info;
69 }
70
GetProcessID()71 lldb::pid_t SBLaunchInfo::GetProcessID() {
72 LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBLaunchInfo, GetProcessID);
73
74 return m_opaque_sp->GetProcessID();
75 }
76
GetUserID()77 uint32_t SBLaunchInfo::GetUserID() {
78 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetUserID);
79
80 return m_opaque_sp->GetUserID();
81 }
82
GetGroupID()83 uint32_t SBLaunchInfo::GetGroupID() {
84 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetGroupID);
85
86 return m_opaque_sp->GetGroupID();
87 }
88
UserIDIsValid()89 bool SBLaunchInfo::UserIDIsValid() {
90 LLDB_RECORD_METHOD_NO_ARGS(bool, SBLaunchInfo, UserIDIsValid);
91
92 return m_opaque_sp->UserIDIsValid();
93 }
94
GroupIDIsValid()95 bool SBLaunchInfo::GroupIDIsValid() {
96 LLDB_RECORD_METHOD_NO_ARGS(bool, SBLaunchInfo, GroupIDIsValid);
97
98 return m_opaque_sp->GroupIDIsValid();
99 }
100
SetUserID(uint32_t uid)101 void SBLaunchInfo::SetUserID(uint32_t uid) {
102 LLDB_RECORD_METHOD(void, SBLaunchInfo, SetUserID, (uint32_t), uid);
103
104 m_opaque_sp->SetUserID(uid);
105 }
106
SetGroupID(uint32_t gid)107 void SBLaunchInfo::SetGroupID(uint32_t gid) {
108 LLDB_RECORD_METHOD(void, SBLaunchInfo, SetGroupID, (uint32_t), gid);
109
110 m_opaque_sp->SetGroupID(gid);
111 }
112
GetExecutableFile()113 SBFileSpec SBLaunchInfo::GetExecutableFile() {
114 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBLaunchInfo, GetExecutableFile);
115
116 return LLDB_RECORD_RESULT(SBFileSpec(m_opaque_sp->GetExecutableFile()));
117 }
118
SetExecutableFile(SBFileSpec exe_file,bool add_as_first_arg)119 void SBLaunchInfo::SetExecutableFile(SBFileSpec exe_file,
120 bool add_as_first_arg) {
121 LLDB_RECORD_METHOD(void, SBLaunchInfo, SetExecutableFile,
122 (lldb::SBFileSpec, bool), exe_file, add_as_first_arg);
123
124 m_opaque_sp->SetExecutableFile(exe_file.ref(), add_as_first_arg);
125 }
126
GetListener()127 SBListener SBLaunchInfo::GetListener() {
128 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBLaunchInfo, GetListener);
129
130 return LLDB_RECORD_RESULT(SBListener(m_opaque_sp->GetListener()));
131 }
132
SetListener(SBListener & listener)133 void SBLaunchInfo::SetListener(SBListener &listener) {
134 LLDB_RECORD_METHOD(void, SBLaunchInfo, SetListener, (lldb::SBListener &),
135 listener);
136
137 m_opaque_sp->SetListener(listener.GetSP());
138 }
139
GetNumArguments()140 uint32_t SBLaunchInfo::GetNumArguments() {
141 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetNumArguments);
142
143 return m_opaque_sp->GetArguments().GetArgumentCount();
144 }
145
GetArgumentAtIndex(uint32_t idx)146 const char *SBLaunchInfo::GetArgumentAtIndex(uint32_t idx) {
147 LLDB_RECORD_METHOD(const char *, SBLaunchInfo, GetArgumentAtIndex, (uint32_t),
148 idx);
149
150 return m_opaque_sp->GetArguments().GetArgumentAtIndex(idx);
151 }
152
SetArguments(const char ** argv,bool append)153 void SBLaunchInfo::SetArguments(const char **argv, bool append) {
154 LLDB_RECORD_METHOD(void, SBLaunchInfo, SetArguments, (const char **, bool),
155 argv, append);
156
157 if (append) {
158 if (argv)
159 m_opaque_sp->GetArguments().AppendArguments(argv);
160 } else {
161 if (argv)
162 m_opaque_sp->GetArguments().SetArguments(argv);
163 else
164 m_opaque_sp->GetArguments().Clear();
165 }
166 }
167
GetNumEnvironmentEntries()168 uint32_t SBLaunchInfo::GetNumEnvironmentEntries() {
169 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetNumEnvironmentEntries);
170
171 return m_opaque_sp->GetEnvironment().size();
172 }
173
GetEnvironmentEntryAtIndex(uint32_t idx)174 const char *SBLaunchInfo::GetEnvironmentEntryAtIndex(uint32_t idx) {
175 LLDB_RECORD_METHOD(const char *, SBLaunchInfo, GetEnvironmentEntryAtIndex,
176 (uint32_t), idx);
177
178 if (idx > GetNumEnvironmentEntries())
179 return nullptr;
180 return m_opaque_sp->GetEnvp()[idx];
181 }
182
SetEnvironmentEntries(const char ** envp,bool append)183 void SBLaunchInfo::SetEnvironmentEntries(const char **envp, bool append) {
184 LLDB_RECORD_METHOD(void, SBLaunchInfo, SetEnvironmentEntries,
185 (const char **, bool), envp, append);
186 SetEnvironment(SBEnvironment(Environment(envp)), append);
187 }
188
SetEnvironment(const SBEnvironment & env,bool append)189 void SBLaunchInfo::SetEnvironment(const SBEnvironment &env, bool append) {
190 LLDB_RECORD_METHOD(void, SBLaunchInfo, SetEnvironment,
191 (const lldb::SBEnvironment &, bool), env, append);
192 Environment &refEnv = env.ref();
193 if (append) {
194 for (auto &KV : refEnv)
195 m_opaque_sp->GetEnvironment().insert_or_assign(KV.first(), KV.second);
196 } else
197 m_opaque_sp->GetEnvironment() = refEnv;
198 m_opaque_sp->RegenerateEnvp();
199 }
200
GetEnvironment()201 SBEnvironment SBLaunchInfo::GetEnvironment() {
202 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBEnvironment, SBLaunchInfo, GetEnvironment);
203 return LLDB_RECORD_RESULT(
204 SBEnvironment(Environment(m_opaque_sp->GetEnvironment())));
205 }
206
Clear()207 void SBLaunchInfo::Clear() {
208 LLDB_RECORD_METHOD_NO_ARGS(void, SBLaunchInfo, Clear);
209
210 m_opaque_sp->Clear();
211 }
212
GetWorkingDirectory() const213 const char *SBLaunchInfo::GetWorkingDirectory() const {
214 LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBLaunchInfo,
215 GetWorkingDirectory);
216
217 return m_opaque_sp->GetWorkingDirectory().GetCString();
218 }
219
SetWorkingDirectory(const char * working_dir)220 void SBLaunchInfo::SetWorkingDirectory(const char *working_dir) {
221 LLDB_RECORD_METHOD(void, SBLaunchInfo, SetWorkingDirectory, (const char *),
222 working_dir);
223
224 m_opaque_sp->SetWorkingDirectory(FileSpec(working_dir));
225 }
226
GetLaunchFlags()227 uint32_t SBLaunchInfo::GetLaunchFlags() {
228 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetLaunchFlags);
229
230 return m_opaque_sp->GetFlags().Get();
231 }
232
SetLaunchFlags(uint32_t flags)233 void SBLaunchInfo::SetLaunchFlags(uint32_t flags) {
234 LLDB_RECORD_METHOD(void, SBLaunchInfo, SetLaunchFlags, (uint32_t), flags);
235
236 m_opaque_sp->GetFlags().Reset(flags);
237 }
238
GetProcessPluginName()239 const char *SBLaunchInfo::GetProcessPluginName() {
240 LLDB_RECORD_METHOD_NO_ARGS(const char *, SBLaunchInfo, GetProcessPluginName);
241
242 return m_opaque_sp->GetProcessPluginName();
243 }
244
SetProcessPluginName(const char * plugin_name)245 void SBLaunchInfo::SetProcessPluginName(const char *plugin_name) {
246 LLDB_RECORD_METHOD(void, SBLaunchInfo, SetProcessPluginName, (const char *),
247 plugin_name);
248
249 return m_opaque_sp->SetProcessPluginName(plugin_name);
250 }
251
GetShell()252 const char *SBLaunchInfo::GetShell() {
253 LLDB_RECORD_METHOD_NO_ARGS(const char *, SBLaunchInfo, GetShell);
254
255 // Constify this string so that it is saved in the string pool. Otherwise it
256 // would be freed when this function goes out of scope.
257 ConstString shell(m_opaque_sp->GetShell().GetPath().c_str());
258 return shell.AsCString();
259 }
260
SetShell(const char * path)261 void SBLaunchInfo::SetShell(const char *path) {
262 LLDB_RECORD_METHOD(void, SBLaunchInfo, SetShell, (const char *), path);
263
264 m_opaque_sp->SetShell(FileSpec(path));
265 }
266
GetShellExpandArguments()267 bool SBLaunchInfo::GetShellExpandArguments() {
268 LLDB_RECORD_METHOD_NO_ARGS(bool, SBLaunchInfo, GetShellExpandArguments);
269
270 return m_opaque_sp->GetShellExpandArguments();
271 }
272
SetShellExpandArguments(bool expand)273 void SBLaunchInfo::SetShellExpandArguments(bool expand) {
274 LLDB_RECORD_METHOD(void, SBLaunchInfo, SetShellExpandArguments, (bool),
275 expand);
276
277 m_opaque_sp->SetShellExpandArguments(expand);
278 }
279
GetResumeCount()280 uint32_t SBLaunchInfo::GetResumeCount() {
281 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetResumeCount);
282
283 return m_opaque_sp->GetResumeCount();
284 }
285
SetResumeCount(uint32_t c)286 void SBLaunchInfo::SetResumeCount(uint32_t c) {
287 LLDB_RECORD_METHOD(void, SBLaunchInfo, SetResumeCount, (uint32_t), c);
288
289 m_opaque_sp->SetResumeCount(c);
290 }
291
AddCloseFileAction(int fd)292 bool SBLaunchInfo::AddCloseFileAction(int fd) {
293 LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddCloseFileAction, (int), fd);
294
295 return m_opaque_sp->AppendCloseFileAction(fd);
296 }
297
AddDuplicateFileAction(int fd,int dup_fd)298 bool SBLaunchInfo::AddDuplicateFileAction(int fd, int dup_fd) {
299 LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddDuplicateFileAction, (int, int), fd,
300 dup_fd);
301
302 return m_opaque_sp->AppendDuplicateFileAction(fd, dup_fd);
303 }
304
AddOpenFileAction(int fd,const char * path,bool read,bool write)305 bool SBLaunchInfo::AddOpenFileAction(int fd, const char *path, bool read,
306 bool write) {
307 LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddOpenFileAction,
308 (int, const char *, bool, bool), fd, path, read, write);
309
310 return m_opaque_sp->AppendOpenFileAction(fd, FileSpec(path), read, write);
311 }
312
AddSuppressFileAction(int fd,bool read,bool write)313 bool SBLaunchInfo::AddSuppressFileAction(int fd, bool read, bool write) {
314 LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddSuppressFileAction,
315 (int, bool, bool), fd, read, write);
316
317 return m_opaque_sp->AppendSuppressFileAction(fd, read, write);
318 }
319
SetLaunchEventData(const char * data)320 void SBLaunchInfo::SetLaunchEventData(const char *data) {
321 LLDB_RECORD_METHOD(void, SBLaunchInfo, SetLaunchEventData, (const char *),
322 data);
323
324 m_opaque_sp->SetLaunchEventData(data);
325 }
326
GetLaunchEventData() const327 const char *SBLaunchInfo::GetLaunchEventData() const {
328 LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBLaunchInfo,
329 GetLaunchEventData);
330
331 return m_opaque_sp->GetLaunchEventData();
332 }
333
SetDetachOnError(bool enable)334 void SBLaunchInfo::SetDetachOnError(bool enable) {
335 LLDB_RECORD_METHOD(void, SBLaunchInfo, SetDetachOnError, (bool), enable);
336
337 m_opaque_sp->SetDetachOnError(enable);
338 }
339
GetDetachOnError() const340 bool SBLaunchInfo::GetDetachOnError() const {
341 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBLaunchInfo, GetDetachOnError);
342
343 return m_opaque_sp->GetDetachOnError();
344 }
345
346 namespace lldb_private {
347 namespace repro {
348
349 template <>
RegisterMethods(Registry & R)350 void RegisterMethods<SBLaunchInfo>(Registry &R) {
351 LLDB_REGISTER_CONSTRUCTOR(SBLaunchInfo, (const char **));
352 LLDB_REGISTER_CONSTRUCTOR(SBLaunchInfo, (const lldb::SBLaunchInfo &));
353 LLDB_REGISTER_METHOD(SBLaunchInfo &,
354 SBLaunchInfo, operator=,(const lldb::SBLaunchInfo &));
355 LLDB_REGISTER_METHOD(lldb::pid_t, SBLaunchInfo, GetProcessID, ());
356 LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetUserID, ());
357 LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetGroupID, ());
358 LLDB_REGISTER_METHOD(bool, SBLaunchInfo, UserIDIsValid, ());
359 LLDB_REGISTER_METHOD(bool, SBLaunchInfo, GroupIDIsValid, ());
360 LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetUserID, (uint32_t));
361 LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetGroupID, (uint32_t));
362 LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBLaunchInfo, GetExecutableFile, ());
363 LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetExecutableFile,
364 (lldb::SBFileSpec, bool));
365 LLDB_REGISTER_METHOD(lldb::SBListener, SBLaunchInfo, GetListener, ());
366 LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetListener, (lldb::SBListener &));
367 LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetNumArguments, ());
368 LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetArgumentAtIndex,
369 (uint32_t));
370 LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetArguments,
371 (const char **, bool));
372 LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetNumEnvironmentEntries, ());
373 LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetEnvironmentEntryAtIndex,
374 (uint32_t));
375 LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetEnvironmentEntries,
376 (const char **, bool));
377 LLDB_REGISTER_METHOD(void, SBLaunchInfo, Clear, ());
378 LLDB_REGISTER_METHOD_CONST(const char *, SBLaunchInfo, GetWorkingDirectory,
379 ());
380 LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetWorkingDirectory,
381 (const char *));
382 LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetLaunchFlags, ());
383 LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetLaunchFlags, (uint32_t));
384 LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetProcessPluginName, ());
385 LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetProcessPluginName,
386 (const char *));
387 LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetShell, ());
388 LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetShell, (const char *));
389 LLDB_REGISTER_METHOD(bool, SBLaunchInfo, GetShellExpandArguments, ());
390 LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetShellExpandArguments, (bool));
391 LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetResumeCount, ());
392 LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetResumeCount, (uint32_t));
393 LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddCloseFileAction, (int));
394 LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddDuplicateFileAction,
395 (int, int));
396 LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddOpenFileAction,
397 (int, const char *, bool, bool));
398 LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddSuppressFileAction,
399 (int, bool, bool));
400 LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetLaunchEventData,
401 (const char *));
402 LLDB_REGISTER_METHOD_CONST(const char *, SBLaunchInfo, GetLaunchEventData,
403 ());
404 LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetDetachOnError, (bool));
405 LLDB_REGISTER_METHOD_CONST(bool, SBLaunchInfo, GetDetachOnError, ());
406 LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetEnvironment,
407 (const lldb::SBEnvironment &, bool));
408 LLDB_REGISTER_METHOD(lldb::SBEnvironment, SBLaunchInfo, GetEnvironment, ());
409 }
410
411 }
412 }
413