lldb/source/API/SBAttachInfo.cpp

   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
  16 using namespace lldb;
  17 using namespace lldb_private;
  18
  19 SBAttachInfo::SBAttachInfo() : m_opaque_sp(new ProcessAttachInfo()) {
  20   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBAttachInfo);
  21 }
  22
  23 SBAttachInfo::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
  30 SBAttachInfo::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
  39 SBAttachInfo::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
  50 SBAttachInfo::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
  57 SBAttachInfo::~SBAttachInfo() {}
  58
  59 lldb_private::ProcessAttachInfo &SBAttachInfo::ref() { return *m_opaque_sp; }
  60
  61 SBAttachInfo &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
  70 lldb::pid_t SBAttachInfo::GetProcessID() {
  71   LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBAttachInfo, GetProcessID);
  72
  73   return m_opaque_sp->GetProcessID();
  74 }
  75
  76 void 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
  82 uint32_t SBAttachInfo::GetResumeCount() {
  83   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetResumeCount);
  84
  85   return m_opaque_sp->GetResumeCount();
  86 }
  87
  88 void SBAttachInfo::SetResumeCount(uint32_t c) {
  89   LLDB_RECORD_METHOD(void, SBAttachInfo, SetResumeCount, (uint32_t), c);
  90
  91   m_opaque_sp->SetResumeCount(c);
  92 }
  93
  94 const char *SBAttachInfo::GetProcessPluginName() {
  95   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBAttachInfo, GetProcessPluginName);
  96
  97   return m_opaque_sp->GetProcessPluginName();
  98 }
  99
 100 void 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
 107 void 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
 116 void 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
 126 bool SBAttachInfo::GetWaitForLaunch() {
 127   LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, GetWaitForLaunch);
 128
 129   return m_opaque_sp->GetWaitForLaunch();
 130 }
 131
 132 void SBAttachInfo::SetWaitForLaunch(bool b) {
 133   LLDB_RECORD_METHOD(void, SBAttachInfo, SetWaitForLaunch, (bool), b);
 134
 135   m_opaque_sp->SetWaitForLaunch(b);
 136 }
 137
 138 void 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
 146 bool SBAttachInfo::GetIgnoreExisting() {
 147   LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, GetIgnoreExisting);
 148
 149   return m_opaque_sp->GetIgnoreExisting();
 150 }
 151
 152 void SBAttachInfo::SetIgnoreExisting(bool b) {
 153   LLDB_RECORD_METHOD(void, SBAttachInfo, SetIgnoreExisting, (bool), b);
 154
 155   m_opaque_sp->SetIgnoreExisting(b);
 156 }
 157
 158 uint32_t SBAttachInfo::GetUserID() {
 159   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetUserID);
 160
 161   return m_opaque_sp->GetUserID();
 162 }
 163
 164 uint32_t SBAttachInfo::GetGroupID() {
 165   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetGroupID);
 166
 167   return m_opaque_sp->GetGroupID();
 168 }
 169
 170 bool SBAttachInfo::UserIDIsValid() {
 171   LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, UserIDIsValid);
 172
 173   return m_opaque_sp->UserIDIsValid();
 174 }
 175
 176 bool SBAttachInfo::GroupIDIsValid() {
 177   LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, GroupIDIsValid);
 178
 179   return m_opaque_sp->GroupIDIsValid();
 180 }
 181
 182 void SBAttachInfo::SetUserID(uint32_t uid) {
 183   LLDB_RECORD_METHOD(void, SBAttachInfo, SetUserID, (uint32_t), uid);
 184
 185   m_opaque_sp->SetUserID(uid);
 186 }
 187
 188 void SBAttachInfo::SetGroupID(uint32_t gid) {
 189   LLDB_RECORD_METHOD(void, SBAttachInfo, SetGroupID, (uint32_t), gid);
 190
 191   m_opaque_sp->SetGroupID(gid);
 192 }
 193
 194 uint32_t SBAttachInfo::GetEffectiveUserID() {
 195   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetEffectiveUserID);
 196
 197   return m_opaque_sp->GetEffectiveUserID();
 198 }
 199
 200 uint32_t SBAttachInfo::GetEffectiveGroupID() {
 201   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBAttachInfo, GetEffectiveGroupID);
 202
 203   return m_opaque_sp->GetEffectiveGroupID();
 204 }
 205
 206 bool SBAttachInfo::EffectiveUserIDIsValid() {
 207   LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, EffectiveUserIDIsValid);
 208
 209   return m_opaque_sp->EffectiveUserIDIsValid();
 210 }
 211
 212 bool SBAttachInfo::EffectiveGroupIDIsValid() {
 213   LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, EffectiveGroupIDIsValid);
 214
 215   return m_opaque_sp->EffectiveGroupIDIsValid();
 216 }
 217
 218 void SBAttachInfo::SetEffectiveUserID(uint32_t uid) {
 219   LLDB_RECORD_METHOD(void, SBAttachInfo, SetEffectiveUserID, (uint32_t), uid);
 220
 221   m_opaque_sp->SetEffectiveUserID(uid);
 222 }
 223
 224 void SBAttachInfo::SetEffectiveGroupID(uint32_t gid) {
 225   LLDB_RECORD_METHOD(void, SBAttachInfo, SetEffectiveGroupID, (uint32_t), gid);
 226
 227   m_opaque_sp->SetEffectiveGroupID(gid);
 228 }
 229
 230 lldb::pid_t SBAttachInfo::GetParentProcessID() {
 231   LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBAttachInfo, GetParentProcessID);
 232
 233   return m_opaque_sp->GetParentProcessID();
 234 }
 235
 236 void 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
 243 bool SBAttachInfo::ParentProcessIDIsValid() {
 244   LLDB_RECORD_METHOD_NO_ARGS(bool, SBAttachInfo, ParentProcessIDIsValid);
 245
 246   return m_opaque_sp->ParentProcessIDIsValid();
 247 }
 248
 249 SBListener 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
 255 void 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
 262 namespace lldb_private {
 263 namespace repro {
 264
 265 template <>
 266 void 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 }