LLDB  mainline
SBLaunchInfo.cpp
Go to the documentation of this file.
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 
10 #include "SBReproducerPrivate.h"
11 
12 #include "lldb/API/SBEnvironment.h"
13 #include "lldb/API/SBError.h"
14 #include "lldb/API/SBFileSpec.h"
15 #include "lldb/API/SBListener.h"
16 #include "lldb/API/SBStream.h"
20 
21 using namespace lldb;
22 using namespace lldb_private;
23 
25 public:
27  : ProcessLaunchInfo(), m_envp(GetEnvironment().getEnvp()) {}
28 
29  const char *const *GetEnvp() const { return m_envp; }
30  void RegenerateEnvp() { m_envp = GetEnvironment().getEnvp(); }
31 
33  ProcessLaunchInfo::operator=(rhs);
34  RegenerateEnvp();
35  return *this;
36  }
37 
38 private:
40 };
41 
42 SBLaunchInfo::SBLaunchInfo(const char **argv)
43  : m_opaque_sp(new SBLaunchInfoImpl()) {
44  LLDB_RECORD_CONSTRUCTOR(SBLaunchInfo, (const char **), argv);
45 
46  m_opaque_sp->GetFlags().Reset(eLaunchFlagDebug | eLaunchFlagDisableASLR);
47  if (argv && argv[0])
48  m_opaque_sp->GetArguments().SetArguments(argv);
49 }
50 
53 
55 }
56 
59  SBLaunchInfo, operator=,(const lldb::SBLaunchInfo &), rhs);
60 
62  return LLDB_RECORD_RESULT(*this);
63 }
64 
65 SBLaunchInfo::~SBLaunchInfo() = default;
66 
68  return *m_opaque_sp;
69 }
70 
72  *m_opaque_sp = info;
73 }
74 
77 
78  return m_opaque_sp->GetProcessID();
79 }
80 
83 
84  return m_opaque_sp->GetUserID();
85 }
86 
89 
90  return m_opaque_sp->GetGroupID();
91 }
92 
95 
96  return m_opaque_sp->UserIDIsValid();
97 }
98 
101 
102  return m_opaque_sp->GroupIDIsValid();
103 }
104 
107 
108  m_opaque_sp->SetUserID(uid);
109 }
110 
113 
114  m_opaque_sp->SetGroupID(gid);
115 }
116 
119 
120  return LLDB_RECORD_RESULT(SBFileSpec(m_opaque_sp->GetExecutableFile()));
121 }
122 
124  bool add_as_first_arg) {
126  (lldb::SBFileSpec, bool), exe_file, add_as_first_arg);
127 
128  m_opaque_sp->SetExecutableFile(exe_file.ref(), add_as_first_arg);
129 }
130 
133 
134  return LLDB_RECORD_RESULT(SBListener(m_opaque_sp->GetListener()));
135 }
136 
139  listener);
140 
141  m_opaque_sp->SetListener(listener.GetSP());
142 }
143 
146 
147  return m_opaque_sp->GetArguments().GetArgumentCount();
148 }
149 
152  idx);
153 
154  return m_opaque_sp->GetArguments().GetArgumentAtIndex(idx);
155 }
156 
157 void SBLaunchInfo::SetArguments(const char **argv, bool append) {
158  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetArguments, (const char **, bool),
159  argv, append);
160 
161  if (append) {
162  if (argv)
163  m_opaque_sp->GetArguments().AppendArguments(argv);
164  } else {
165  if (argv)
166  m_opaque_sp->GetArguments().SetArguments(argv);
167  else
168  m_opaque_sp->GetArguments().Clear();
169  }
170 }
171 
174 
175  return m_opaque_sp->GetEnvironment().size();
176 }
177 
180  (uint32_t), idx);
181 
182  if (idx > GetNumEnvironmentEntries())
183  return nullptr;
184  return m_opaque_sp->GetEnvp()[idx];
185 }
186 
187 void SBLaunchInfo::SetEnvironmentEntries(const char **envp, bool append) {
189  (const char **, bool), envp, append);
190  SetEnvironment(SBEnvironment(Environment(envp)), append);
191 }
192 
193 void SBLaunchInfo::SetEnvironment(const SBEnvironment &env, bool append) {
195  (const lldb::SBEnvironment &, bool), env, append);
196  Environment &refEnv = env.ref();
197  if (append) {
198  for (auto &KV : refEnv)
199  m_opaque_sp->GetEnvironment().insert_or_assign(KV.first(), KV.second);
200  } else
201  m_opaque_sp->GetEnvironment() = refEnv;
202  m_opaque_sp->RegenerateEnvp();
203 }
204 
207  return LLDB_RECORD_RESULT(
208  SBEnvironment(Environment(m_opaque_sp->GetEnvironment())));
209 }
210 
213 
214  m_opaque_sp->Clear();
215 }
216 
220 
221  return m_opaque_sp->GetWorkingDirectory().GetCString();
222 }
223 
224 void SBLaunchInfo::SetWorkingDirectory(const char *working_dir) {
225  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetWorkingDirectory, (const char *),
226  working_dir);
227 
228  m_opaque_sp->SetWorkingDirectory(FileSpec(working_dir));
229 }
230 
233 
234  return m_opaque_sp->GetFlags().Get();
235 }
236 
239 
240  m_opaque_sp->GetFlags().Reset(flags);
241 }
242 
245 
246  return m_opaque_sp->GetProcessPluginName();
247 }
248 
249 void SBLaunchInfo::SetProcessPluginName(const char *plugin_name) {
251  plugin_name);
252 
253  return m_opaque_sp->SetProcessPluginName(plugin_name);
254 }
255 
256 const char *SBLaunchInfo::GetShell() {
258 
259  // Constify this string so that it is saved in the string pool. Otherwise it
260  // would be freed when this function goes out of scope.
261  ConstString shell(m_opaque_sp->GetShell().GetPath().c_str());
262  return shell.AsCString();
263 }
264 
265 void SBLaunchInfo::SetShell(const char *path) {
266  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetShell, (const char *), path);
267 
268  m_opaque_sp->SetShell(FileSpec(path));
269 }
270 
273 
274  return m_opaque_sp->GetShellExpandArguments();
275 }
276 
279  expand);
280 
281  m_opaque_sp->SetShellExpandArguments(expand);
282 }
283 
286 
287  return m_opaque_sp->GetResumeCount();
288 }
289 
292 
293  m_opaque_sp->SetResumeCount(c);
294 }
295 
298 
299  return m_opaque_sp->AppendCloseFileAction(fd);
300 }
301 
302 bool SBLaunchInfo::AddDuplicateFileAction(int fd, int dup_fd) {
304  dup_fd);
305 
306  return m_opaque_sp->AppendDuplicateFileAction(fd, dup_fd);
307 }
308 
309 bool SBLaunchInfo::AddOpenFileAction(int fd, const char *path, bool read,
310  bool write) {
312  (int, const char *, bool, bool), fd, path, read, write);
313 
314  return m_opaque_sp->AppendOpenFileAction(fd, FileSpec(path), read, write);
315 }
316 
317 bool SBLaunchInfo::AddSuppressFileAction(int fd, bool read, bool write) {
319  (int, bool, bool), fd, read, write);
320 
321  return m_opaque_sp->AppendSuppressFileAction(fd, read, write);
322 }
323 
324 void SBLaunchInfo::SetLaunchEventData(const char *data) {
325  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetLaunchEventData, (const char *),
326  data);
327 
328  m_opaque_sp->SetLaunchEventData(data);
329 }
330 
331 const char *SBLaunchInfo::GetLaunchEventData() const {
334 
335  return m_opaque_sp->GetLaunchEventData();
336 }
337 
339  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetDetachOnError, (bool), enable);
340 
341  m_opaque_sp->SetDetachOnError(enable);
342 }
343 
346 
347  return m_opaque_sp->GetDetachOnError();
348 }
349 
353 
354  // Constify this string so that it is saved in the string pool. Otherwise it
355  // would be freed when this function goes out of scope.
356  ConstString class_name(m_opaque_sp->GetScriptedProcessClassName().c_str());
357  return class_name.AsCString();
358 }
359 
360 void SBLaunchInfo::SetScriptedProcessClassName(const char *class_name) {
362  (const char *), class_name);
363 
364  m_opaque_sp->SetScriptedProcessClassName(class_name);
365 }
366 
370 
372  m_opaque_sp->GetScriptedProcessDictionarySP();
373 
374  SBStructuredData data;
375  data.m_impl_up->SetObjectSP(dict_sp);
376 
377  return LLDB_RECORD_RESULT(data);
378 }
379 
382  (lldb::SBStructuredData), dict);
383 
384  SBStream stream;
385  SBError error = dict.GetAsJSON(stream);
386 
387  if (error.Fail())
388  return;
389 
391  llvm::json::OStream s(stream.ref().AsRawOstream());
392  dict_sp->Serialize(s);
393 
394  m_opaque_sp->SetScriptedProcessDictionarySP(dict_sp);
395 }
396 
397 namespace lldb_private {
398 namespace repro {
399 
400 template <>
402  LLDB_REGISTER_CONSTRUCTOR(SBLaunchInfo, (const char **));
405  SBLaunchInfo, operator=,(const lldb::SBLaunchInfo &));
406  LLDB_REGISTER_METHOD(lldb::pid_t, SBLaunchInfo, GetProcessID, ());
407  LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetUserID, ());
408  LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetGroupID, ());
409  LLDB_REGISTER_METHOD(bool, SBLaunchInfo, UserIDIsValid, ());
410  LLDB_REGISTER_METHOD(bool, SBLaunchInfo, GroupIDIsValid, ());
411  LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetUserID, (uint32_t));
412  LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetGroupID, (uint32_t));
413  LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBLaunchInfo, GetExecutableFile, ());
414  LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetExecutableFile,
415  (lldb::SBFileSpec, bool));
417  LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetListener, (lldb::SBListener &));
418  LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetNumArguments, ());
419  LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetArgumentAtIndex,
420  (uint32_t));
421  LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetArguments,
422  (const char **, bool));
423  LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetNumEnvironmentEntries, ());
424  LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetEnvironmentEntryAtIndex,
425  (uint32_t));
426  LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetEnvironmentEntries,
427  (const char **, bool));
428  LLDB_REGISTER_METHOD(void, SBLaunchInfo, Clear, ());
429  LLDB_REGISTER_METHOD_CONST(const char *, SBLaunchInfo, GetWorkingDirectory,
430  ());
431  LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetWorkingDirectory,
432  (const char *));
433  LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetLaunchFlags, ());
434  LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetLaunchFlags, (uint32_t));
435  LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetProcessPluginName, ());
436  LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetProcessPluginName,
437  (const char *));
438  LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetShell, ());
439  LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetShell, (const char *));
440  LLDB_REGISTER_METHOD(bool, SBLaunchInfo, GetShellExpandArguments, ());
441  LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetShellExpandArguments, (bool));
442  LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetResumeCount, ());
443  LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetResumeCount, (uint32_t));
444  LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddCloseFileAction, (int));
445  LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddDuplicateFileAction,
446  (int, int));
447  LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddOpenFileAction,
448  (int, const char *, bool, bool));
449  LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddSuppressFileAction,
450  (int, bool, bool));
451  LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetLaunchEventData,
452  (const char *));
453  LLDB_REGISTER_METHOD_CONST(const char *, SBLaunchInfo, GetLaunchEventData,
454  ());
455  LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetDetachOnError, (bool));
456  LLDB_REGISTER_METHOD_CONST(bool, SBLaunchInfo, GetDetachOnError, ());
458  GetScriptedProcessClassName, ());
459  LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetScriptedProcessClassName,
460  (const char *));
462  GetScriptedProcessDictionary, ());
463  LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetScriptedProcessDictionary,
465  LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetEnvironment,
466  (const lldb::SBEnvironment &, bool));
468 }
469 
470 }
471 }
lldb::SBLaunchInfo
Definition: SBLaunchInfo.h:23
lldb::SBLaunchInfo::GetWorkingDirectory
const char * GetWorkingDirectory() const
Definition: SBLaunchInfo.cpp:217
lldb::SBStream::ref
lldb_private::Stream & ref()
Definition: SBStream.cpp:178
lldb_private::SBLaunchInfoImpl::m_envp
Environment::Envp m_envp
Definition: SBLaunchInfo.cpp:39
lldb::SBLaunchInfo::GetNumEnvironmentEntries
uint32_t GetNumEnvironmentEntries()
Definition: SBLaunchInfo.cpp:172
lldb::SBLaunchInfo::SetResumeCount
void SetResumeCount(uint32_t c)
Definition: SBLaunchInfo.cpp:290
LLDB_RECORD_RESULT
#define LLDB_RECORD_RESULT(Result)
Definition: ReproducerInstrumentation.h:211
lldb::SBEnvironment::ref
lldb_private::Environment & ref() const
Definition: SBEnvironment.cpp:132
lldb_private::Environment::Envp
Definition: Environment.h:22
SBLaunchInfo.h
LLDB_RECORD_METHOD_CONST_NO_ARGS
#define LLDB_RECORD_METHOD_CONST_NO_ARGS(Result, Class, Method)
Definition: ReproducerInstrumentation.h:168
lldb::SBError
Definition: SBError.h:20
lldb::SBLaunchInfo::GetResumeCount
uint32_t GetResumeCount()
Definition: SBLaunchInfo.cpp:284
ProcessLaunchInfo.h
LLDB_RECORD_METHOD_NO_ARGS
#define LLDB_RECORD_METHOD_NO_ARGS(Result, Class, Method)
Definition: ReproducerInstrumentation.h:165
lldb::SBListener
class LLDB_API SBListener
Definition: SBDefines.h:56
lldb::SBLaunchInfo::SetUserID
void SetUserID(uint32_t uid)
Definition: SBLaunchInfo.cpp:105
lldb::SBEnvironment
class LLDB_API SBEnvironment
Definition: SBDefines.h:39
lldb_private::ConstString::AsCString
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
Definition: ConstString.h:193
lldb::SBLaunchInfo::GetShellExpandArguments
bool GetShellExpandArguments()
Definition: SBLaunchInfo.cpp:271
LLDB_REGISTER_METHOD_CONST
#define LLDB_REGISTER_METHOD_CONST(Result, Class, Method, Signature)
Definition: ReproducerInstrumentation.h:98
lldb::SBListener::GetSP
lldb::ListenerSP GetSP()
Definition: SBListener.cpp:315
lldb::SBLaunchInfo::GetLaunchEventData
const char * GetLaunchEventData() const
Definition: SBLaunchInfo.cpp:331
lldb::SBLaunchInfo::GetShell
const char * GetShell()
Definition: SBLaunchInfo.cpp:256
lldb::SBLaunchInfo::GetScriptedProcessDictionary
lldb::SBStructuredData GetScriptedProcessDictionary() const
Definition: SBLaunchInfo.cpp:367
lldb::SBLaunchInfo::AddDuplicateFileAction
bool AddDuplicateFileAction(int fd, int dup_fd)
Definition: SBLaunchInfo.cpp:302
SBReproducerPrivate.h
lldb::SBLaunchInfo::operator=
SBLaunchInfo & operator=(const SBLaunchInfo &rhs)
Definition: SBLaunchInfo.cpp:57
lldb::SBLaunchInfo::UserIDIsValid
bool UserIDIsValid()
Definition: SBLaunchInfo.cpp:93
lldb::SBLaunchInfo::SetScriptedProcessDictionary
void SetScriptedProcessDictionary(lldb::SBStructuredData dict)
Definition: SBLaunchInfo.cpp:380
LLDB_REGISTER_CONSTRUCTOR
#define LLDB_REGISTER_CONSTRUCTOR(Class, Signature)
Definition: ReproducerInstrumentation.h:89
lldb::SBLaunchInfo::GetDetachOnError
bool GetDetachOnError() const
Definition: SBLaunchInfo.cpp:344
SBListener.h
lldb_private::SBLaunchInfoImpl::RegenerateEnvp
void RegenerateEnvp()
Definition: SBLaunchInfo.cpp:30
lldb::SBLaunchInfo::SetListener
void SetListener(SBListener &listener)
Set the listener that will be used to receive process events.
Definition: SBLaunchInfo.cpp:137
lldb::SBStructuredData::m_impl_up
StructuredDataImplUP m_impl_up
Definition: SBStructuredData.h:104
lldb_private::repro::RegisterMethods< SBLaunchInfo >
void RegisterMethods< SBLaunchInfo >(Registry &R)
Definition: SBLaunchInfo.cpp:401
lldb_private::FileSpec
Definition: FileSpec.h:56
lldb::SBLaunchInfo::m_opaque_sp
std::shared_ptr< lldb_private::SBLaunchInfoImpl > m_opaque_sp
Definition: SBLaunchInfo.h:189
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
lldb::SBLaunchInfo::~SBLaunchInfo
~SBLaunchInfo()
SBStream.h
lldb::SBLaunchInfo::SetEnvironmentEntries
void SetEnvironmentEntries(const char **envp, bool append)
Update this object with the given environment variables.
Definition: SBLaunchInfo.cpp:187
lldb::SBLaunchInfo::GetListener
SBListener GetListener()
Get the listener that will be used to receive process events.
Definition: SBLaunchInfo.cpp:131
LLDB_RECORD_METHOD
#define LLDB_RECORD_METHOD(Result, Class, Method, Signature,...)
Definition: ReproducerInstrumentation.h:158
lldb_private::ProcessLaunchInfo
Definition: ProcessLaunchInfo.h:31
lldb::SBStructuredData::GetAsJSON
lldb::SBError GetAsJSON(lldb::SBStream &stream) const
Definition: SBStructuredData.cpp:100
lldb::SBLaunchInfo::AddCloseFileAction
bool AddCloseFileAction(int fd)
Definition: SBLaunchInfo.cpp:296
SBFileSpec.h
lldb::SBLaunchInfo::SetLaunchFlags
void SetLaunchFlags(uint32_t flags)
Definition: SBLaunchInfo.cpp:237
lldb::SBLaunchInfo::SetLaunchEventData
void SetLaunchEventData(const char *data)
Definition: SBLaunchInfo.cpp:324
lldb_private::ConstString
Definition: ConstString.h:40
lldb::SBLaunchInfo::GetExecutableFile
SBFileSpec GetExecutableFile()
Definition: SBLaunchInfo.cpp:117
lldb::SBFileSpec::ref
const lldb_private::FileSpec & ref() const
Definition: SBFileSpec.cpp:168
lldb_private::SBLaunchInfoImpl::operator=
SBLaunchInfoImpl & operator=(const ProcessLaunchInfo &rhs)
Definition: SBLaunchInfo.cpp:32
lldb::SBEnvironment
Definition: SBEnvironment.h:16
lldb::SBLaunchInfo::GetArgumentAtIndex
const char * GetArgumentAtIndex(uint32_t idx)
Definition: SBLaunchInfo.cpp:150
lldb_private::StructuredData::DictionarySP
std::shared_ptr< Dictionary > DictionarySP
Definition: StructuredData.h:67
lldb::SBLaunchInfo::GetGroupID
uint32_t GetGroupID()
Definition: SBLaunchInfo.cpp:87
lldb::SBLaunchInfo::SetDetachOnError
void SetDetachOnError(bool enable)
Definition: SBLaunchInfo.cpp:338
lldb::SBLaunchInfo::SBLaunchInfo
SBLaunchInfo(const char **argv)
Definition: SBLaunchInfo.cpp:42
lldb::SBLaunchInfo::GetEnvironment
SBEnvironment GetEnvironment()
Return the environment variables of this object.
Definition: SBLaunchInfo.cpp:205
lldb::SBLaunchInfo::GetNumArguments
uint32_t GetNumArguments()
Definition: SBLaunchInfo.cpp:144
LLDB_RECORD_CONSTRUCTOR
#define LLDB_RECORD_CONSTRUCTOR(Class, Signature,...)
Definition: ReproducerInstrumentation.h:133
lldb::SBLaunchInfo::SetExecutableFile
void SetExecutableFile(SBFileSpec exe_file, bool add_as_first_arg)
Set the executable file that will be used to launch the process and optionally set it as the first ar...
Definition: SBLaunchInfo.cpp:123
lldb_private::repro::Registry
The registry contains a unique mapping between functions and their ID.
Definition: ReproducerInstrumentation.h:517
lldb::SBLaunchInfo::GetEnvironmentEntryAtIndex
const char * GetEnvironmentEntryAtIndex(uint32_t idx)
Definition: SBLaunchInfo.cpp:178
lldb::SBLaunchInfo::GetLaunchFlags
uint32_t GetLaunchFlags()
Definition: SBLaunchInfo.cpp:231
lldb::SBListener
Definition: SBListener.h:16
lldb::SBLaunchInfo::ref
const lldb_private::ProcessLaunchInfo & ref() const
Definition: SBLaunchInfo.cpp:67
lldb_private::SBLaunchInfoImpl::SBLaunchInfoImpl
SBLaunchInfoImpl()
Definition: SBLaunchInfo.cpp:26
lldb::SBLaunchInfo::GetProcessID
lldb::pid_t GetProcessID()
Definition: SBLaunchInfo.cpp:75
uint32_t
lldb::SBStructuredData
Definition: SBStructuredData.h:17
lldb::SBLaunchInfo::Clear
void Clear()
Definition: SBLaunchInfo.cpp:211
lldb::pid_t
uint64_t pid_t
Definition: lldb-types.h:85
lldb::SBLaunchInfo::AddOpenFileAction
bool AddOpenFileAction(int fd, const char *path, bool read, bool write)
Definition: SBLaunchInfo.cpp:309
lldb::SBLaunchInfo::SetGroupID
void SetGroupID(uint32_t gid)
Definition: SBLaunchInfo.cpp:111
lldb_private::Stream::AsRawOstream
llvm::raw_ostream & AsRawOstream()
Returns a raw_ostream that forwards the data to this Stream object.
Definition: Stream.h:357
lldb_private::Environment
Definition: Environment.h:18
lldb::SBLaunchInfo::set_ref
void set_ref(const lldb_private::ProcessLaunchInfo &info)
Definition: SBLaunchInfo.cpp:71
SBStructuredData.h
lldb::SBFileSpec
Definition: SBFileSpec.h:16
StructuredDataImpl.h
SBEnvironment.h
lldb::SBLaunchInfo::SetEnvironment
void SetEnvironment(const SBEnvironment &env, bool append)
Update this object with the given environment variables.
Definition: SBLaunchInfo.cpp:193
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb::SBLaunchInfo::SetArguments
void SetArguments(const char **argv, bool append)
Definition: SBLaunchInfo.cpp:157
lldb::SBLaunchInfo::GetUserID
uint32_t GetUserID()
Definition: SBLaunchInfo.cpp:81
lldb::SBLaunchInfo::SetWorkingDirectory
void SetWorkingDirectory(const char *working_dir)
Definition: SBLaunchInfo.cpp:224
lldb::SBLaunchInfo::GetScriptedProcessClassName
const char * GetScriptedProcessClassName() const
Definition: SBLaunchInfo.cpp:350
lldb::SBLaunchInfo::GroupIDIsValid
bool GroupIDIsValid()
Definition: SBLaunchInfo.cpp:99
lldb_private::SBLaunchInfoImpl::GetEnvp
const char *const * GetEnvp() const
Definition: SBLaunchInfo.cpp:29
lldb::SBLaunchInfo::AddSuppressFileAction
bool AddSuppressFileAction(int fd, bool read, bool write)
Definition: SBLaunchInfo.cpp:317
lldb::SBLaunchInfo::SetScriptedProcessClassName
void SetScriptedProcessClassName(const char *class_name)
Definition: SBLaunchInfo.cpp:360
lldb::SBLaunchInfo::SetShellExpandArguments
void SetShellExpandArguments(bool expand)
Definition: SBLaunchInfo.cpp:277
lldb::SBStream
Definition: SBStream.h:18
lldb_private::SBLaunchInfoImpl
Definition: SBLaunchInfo.cpp:24
lldb::SBLaunchInfo::SetProcessPluginName
void SetProcessPluginName(const char *plugin_name)
Definition: SBLaunchInfo.cpp:249
lldb
Definition: SBAddress.h:15
lldb::SBFileSpec
class LLDB_API SBFileSpec
Definition: SBDefines.h:46
lldb::SBLaunchInfo::SetShell
void SetShell(const char *path)
Definition: SBLaunchInfo.cpp:265
SBError.h
LLDB_REGISTER_METHOD
#define LLDB_REGISTER_METHOD(Result, Class, Method, Signature)
Definition: ReproducerInstrumentation.h:93
lldb::SBLaunchInfo::GetProcessPluginName
const char * GetProcessPluginName()
Definition: SBLaunchInfo.cpp:243