lldb/source/API/SBLaunchInfo.cpp

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