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