180814287SRaphael Isemann //===-- SBBreakpointName.cpp ----------------------------------------------===// 2b842f2ecSJim Ingham // 32946cd70SChandler Carruth // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 42946cd70SChandler Carruth // See https://llvm.org/LICENSE.txt for license information. 52946cd70SChandler Carruth // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6b842f2ecSJim Ingham // 7b842f2ecSJim Ingham //===----------------------------------------------------------------------===// 8b842f2ecSJim Ingham 9b842f2ecSJim Ingham #include "lldb/API/SBBreakpointName.h" 10baf5664fSJonas Devlieghere #include "SBReproducerPrivate.h" 11b842f2ecSJim Ingham #include "lldb/API/SBDebugger.h" 12b842f2ecSJim Ingham #include "lldb/API/SBError.h" 13b842f2ecSJim Ingham #include "lldb/API/SBStream.h" 14b842f2ecSJim Ingham #include "lldb/API/SBStringList.h" 15738af7a6SJim Ingham #include "lldb/API/SBStructuredData.h" 16b842f2ecSJim Ingham #include "lldb/API/SBTarget.h" 17b842f2ecSJim Ingham 18b842f2ecSJim Ingham #include "lldb/Breakpoint/BreakpointName.h" 19b842f2ecSJim Ingham #include "lldb/Breakpoint/StoppointCallbackContext.h" 20b842f2ecSJim Ingham #include "lldb/Core/Debugger.h" 21738af7a6SJim Ingham #include "lldb/Core/StructuredDataImpl.h" 22b842f2ecSJim Ingham #include "lldb/Interpreter/CommandInterpreter.h" 23b842f2ecSJim Ingham #include "lldb/Interpreter/ScriptInterpreter.h" 24b842f2ecSJim Ingham #include "lldb/Target/Target.h" 25b842f2ecSJim Ingham #include "lldb/Target/ThreadSpec.h" 26b842f2ecSJim Ingham #include "lldb/Utility/Stream.h" 27b842f2ecSJim Ingham 28b842f2ecSJim Ingham #include "SBBreakpointOptionCommon.h" 29b842f2ecSJim Ingham 30b842f2ecSJim Ingham using namespace lldb; 31b842f2ecSJim Ingham using namespace lldb_private; 32b842f2ecSJim Ingham 33b842f2ecSJim Ingham namespace lldb 34b842f2ecSJim Ingham { 35b842f2ecSJim Ingham class SBBreakpointNameImpl { 36b842f2ecSJim Ingham public: 37c218ee58SDavide Italiano SBBreakpointNameImpl(TargetSP target_sp, const char *name) { 38b842f2ecSJim Ingham if (!name || name[0] == '\0') 39b842f2ecSJim Ingham return; 40b842f2ecSJim Ingham m_name.assign(name); 41b842f2ecSJim Ingham 42b842f2ecSJim Ingham if (!target_sp) 43b842f2ecSJim Ingham return; 44b842f2ecSJim Ingham 45b842f2ecSJim Ingham m_target_wp = target_sp; 46b842f2ecSJim Ingham } 47b842f2ecSJim Ingham 48c218ee58SDavide Italiano SBBreakpointNameImpl(SBTarget &sb_target, const char *name); 49c218ee58SDavide Italiano bool operator==(const SBBreakpointNameImpl &rhs); 50c218ee58SDavide Italiano bool operator!=(const SBBreakpointNameImpl &rhs); 51b842f2ecSJim Ingham 5205097246SAdrian Prantl // For now we take a simple approach and only keep the name, and relook up 5305097246SAdrian Prantl // the location when we need it. 54b842f2ecSJim Ingham 55576628bdSJim Ingham TargetSP GetTarget() const { 56b842f2ecSJim Ingham return m_target_wp.lock(); 57b842f2ecSJim Ingham } 58b842f2ecSJim Ingham 59576628bdSJim Ingham const char *GetName() const { 60b842f2ecSJim Ingham return m_name.c_str(); 61b842f2ecSJim Ingham } 62b842f2ecSJim Ingham 63576628bdSJim Ingham bool IsValid() const { 64b842f2ecSJim Ingham return !m_name.empty() && m_target_wp.lock(); 65b842f2ecSJim Ingham } 66b842f2ecSJim Ingham 67c218ee58SDavide Italiano lldb_private::BreakpointName *GetBreakpointName() const; 68b842f2ecSJim Ingham 69b842f2ecSJim Ingham private: 70b842f2ecSJim Ingham TargetWP m_target_wp; 71b842f2ecSJim Ingham std::string m_name; 72b842f2ecSJim Ingham }; 73c218ee58SDavide Italiano 74c218ee58SDavide Italiano SBBreakpointNameImpl::SBBreakpointNameImpl(SBTarget &sb_target, 75c218ee58SDavide Italiano const char *name) { 76c218ee58SDavide Italiano if (!name || name[0] == '\0') 77c218ee58SDavide Italiano return; 78c218ee58SDavide Italiano m_name.assign(name); 79c218ee58SDavide Italiano 80c218ee58SDavide Italiano if (!sb_target.IsValid()) 81c218ee58SDavide Italiano return; 82c218ee58SDavide Italiano 83c218ee58SDavide Italiano TargetSP target_sp = sb_target.GetSP(); 84c218ee58SDavide Italiano if (!target_sp) 85c218ee58SDavide Italiano return; 86c218ee58SDavide Italiano 87c218ee58SDavide Italiano m_target_wp = target_sp; 88c218ee58SDavide Italiano } 89c218ee58SDavide Italiano 90c218ee58SDavide Italiano bool SBBreakpointNameImpl::operator==(const SBBreakpointNameImpl &rhs) { 91c218ee58SDavide Italiano return m_name == rhs.m_name && m_target_wp.lock() == rhs.m_target_wp.lock(); 92c218ee58SDavide Italiano } 93c218ee58SDavide Italiano 94c218ee58SDavide Italiano bool SBBreakpointNameImpl::operator!=(const SBBreakpointNameImpl &rhs) { 95c218ee58SDavide Italiano return m_name != rhs.m_name || m_target_wp.lock() != rhs.m_target_wp.lock(); 96c218ee58SDavide Italiano } 97c218ee58SDavide Italiano 98c218ee58SDavide Italiano lldb_private::BreakpointName *SBBreakpointNameImpl::GetBreakpointName() const { 99c218ee58SDavide Italiano if (!IsValid()) 100c218ee58SDavide Italiano return nullptr; 101c218ee58SDavide Italiano TargetSP target_sp = GetTarget(); 102c218ee58SDavide Italiano if (!target_sp) 103c218ee58SDavide Italiano return nullptr; 104c218ee58SDavide Italiano Status error; 105c218ee58SDavide Italiano return target_sp->FindBreakpointName(ConstString(m_name), true, error); 106c218ee58SDavide Italiano } 107c218ee58SDavide Italiano 108b842f2ecSJim Ingham } // namespace lldb 109b842f2ecSJim Ingham 110baf5664fSJonas Devlieghere SBBreakpointName::SBBreakpointName() { 111baf5664fSJonas Devlieghere LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBreakpointName); 112baf5664fSJonas Devlieghere } 113b842f2ecSJim Ingham 114baf5664fSJonas Devlieghere SBBreakpointName::SBBreakpointName(SBTarget &sb_target, const char *name) { 115baf5664fSJonas Devlieghere LLDB_RECORD_CONSTRUCTOR(SBBreakpointName, (lldb::SBTarget &, const char *), 116baf5664fSJonas Devlieghere sb_target, name); 117baf5664fSJonas Devlieghere 1181c0bbe43SJonas Devlieghere m_impl_up = std::make_unique<SBBreakpointNameImpl>(sb_target, name); 11905097246SAdrian Prantl // Call FindBreakpointName here to make sure the name is valid, reset if not: 120b842f2ecSJim Ingham BreakpointName *bp_name = GetBreakpointName(); 121b842f2ecSJim Ingham if (!bp_name) 122b842f2ecSJim Ingham m_impl_up.reset(); 123b842f2ecSJim Ingham } 124b842f2ecSJim Ingham 125baf5664fSJonas Devlieghere SBBreakpointName::SBBreakpointName(SBBreakpoint &sb_bkpt, const char *name) { 126baf5664fSJonas Devlieghere LLDB_RECORD_CONSTRUCTOR(SBBreakpointName, 127baf5664fSJonas Devlieghere (lldb::SBBreakpoint &, const char *), sb_bkpt, name); 128baf5664fSJonas Devlieghere 129b842f2ecSJim Ingham if (!sb_bkpt.IsValid()) { 130b842f2ecSJim Ingham m_impl_up.reset(); 131b842f2ecSJim Ingham return; 132b842f2ecSJim Ingham } 133b842f2ecSJim Ingham BreakpointSP bkpt_sp = sb_bkpt.GetSP(); 134b842f2ecSJim Ingham Target &target = bkpt_sp->GetTarget(); 135b842f2ecSJim Ingham 1361c0bbe43SJonas Devlieghere m_impl_up = 1371c0bbe43SJonas Devlieghere std::make_unique<SBBreakpointNameImpl>(target.shared_from_this(), name); 138b842f2ecSJim Ingham 13905097246SAdrian Prantl // Call FindBreakpointName here to make sure the name is valid, reset if not: 140b842f2ecSJim Ingham BreakpointName *bp_name = GetBreakpointName(); 141b842f2ecSJim Ingham if (!bp_name) { 142b842f2ecSJim Ingham m_impl_up.reset(); 143b842f2ecSJim Ingham return; 144b842f2ecSJim Ingham } 145b842f2ecSJim Ingham 146b842f2ecSJim Ingham // Now copy over the breakpoint's options: 147*cfb96d84SJim Ingham target.ConfigureBreakpointName(*bp_name, bkpt_sp->GetOptions(), 148b842f2ecSJim Ingham BreakpointName::Permissions()); 149b842f2ecSJim Ingham } 150b842f2ecSJim Ingham 151baf5664fSJonas Devlieghere SBBreakpointName::SBBreakpointName(const SBBreakpointName &rhs) { 152baf5664fSJonas Devlieghere LLDB_RECORD_CONSTRUCTOR(SBBreakpointName, (const lldb::SBBreakpointName &), 153baf5664fSJonas Devlieghere rhs); 154baf5664fSJonas Devlieghere 155b842f2ecSJim Ingham if (!rhs.m_impl_up) 156b842f2ecSJim Ingham return; 157b842f2ecSJim Ingham else 1581c0bbe43SJonas Devlieghere m_impl_up = std::make_unique<SBBreakpointNameImpl>( 1591c0bbe43SJonas Devlieghere rhs.m_impl_up->GetTarget(), rhs.m_impl_up->GetName()); 160b842f2ecSJim Ingham } 161b842f2ecSJim Ingham 162b842f2ecSJim Ingham SBBreakpointName::~SBBreakpointName() = default; 163b842f2ecSJim Ingham 164baf5664fSJonas Devlieghere const SBBreakpointName &SBBreakpointName:: 165baf5664fSJonas Devlieghere operator=(const SBBreakpointName &rhs) { 166baf5664fSJonas Devlieghere LLDB_RECORD_METHOD( 167baf5664fSJonas Devlieghere const lldb::SBBreakpointName &, 168baf5664fSJonas Devlieghere SBBreakpointName, operator=,(const lldb::SBBreakpointName &), rhs); 169baf5664fSJonas Devlieghere 170b842f2ecSJim Ingham if (!rhs.m_impl_up) { 171b842f2ecSJim Ingham m_impl_up.reset(); 172306809f2SJonas Devlieghere return LLDB_RECORD_RESULT(*this); 173b842f2ecSJim Ingham } 174b842f2ecSJim Ingham 1751c0bbe43SJonas Devlieghere m_impl_up = std::make_unique<SBBreakpointNameImpl>(rhs.m_impl_up->GetTarget(), 1761c0bbe43SJonas Devlieghere rhs.m_impl_up->GetName()); 177306809f2SJonas Devlieghere return LLDB_RECORD_RESULT(*this); 178b842f2ecSJim Ingham } 179b842f2ecSJim Ingham 180b842f2ecSJim Ingham bool SBBreakpointName::operator==(const lldb::SBBreakpointName &rhs) { 181baf5664fSJonas Devlieghere LLDB_RECORD_METHOD( 182baf5664fSJonas Devlieghere bool, SBBreakpointName, operator==,(const lldb::SBBreakpointName &), rhs); 183baf5664fSJonas Devlieghere 1843447077aSJonas Devlieghere return *m_impl_up == *rhs.m_impl_up; 185b842f2ecSJim Ingham } 186b842f2ecSJim Ingham 187b842f2ecSJim Ingham bool SBBreakpointName::operator!=(const lldb::SBBreakpointName &rhs) { 188baf5664fSJonas Devlieghere LLDB_RECORD_METHOD( 189baf5664fSJonas Devlieghere bool, SBBreakpointName, operator!=,(const lldb::SBBreakpointName &), rhs); 190baf5664fSJonas Devlieghere 1913447077aSJonas Devlieghere return *m_impl_up != *rhs.m_impl_up; 192b842f2ecSJim Ingham } 193b842f2ecSJim Ingham 194b842f2ecSJim Ingham bool SBBreakpointName::IsValid() const { 195baf5664fSJonas Devlieghere LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, IsValid); 1967f5237bcSPavel Labath return this->operator bool(); 1977f5237bcSPavel Labath } 1987f5237bcSPavel Labath SBBreakpointName::operator bool() const { 1997f5237bcSPavel Labath LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, operator bool); 200baf5664fSJonas Devlieghere 201b842f2ecSJim Ingham if (!m_impl_up) 202b842f2ecSJim Ingham return false; 203b842f2ecSJim Ingham return m_impl_up->IsValid(); 204b842f2ecSJim Ingham } 205b842f2ecSJim Ingham 206b842f2ecSJim Ingham const char *SBBreakpointName::GetName() const { 207baf5664fSJonas Devlieghere LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName, GetName); 208baf5664fSJonas Devlieghere 209b842f2ecSJim Ingham if (!m_impl_up) 210b842f2ecSJim Ingham return "<Invalid Breakpoint Name Object>"; 211b842f2ecSJim Ingham return m_impl_up->GetName(); 212b842f2ecSJim Ingham } 213b842f2ecSJim Ingham 214b842f2ecSJim Ingham void SBBreakpointName::SetEnabled(bool enable) { 215baf5664fSJonas Devlieghere LLDB_RECORD_METHOD(void, SBBreakpointName, SetEnabled, (bool), enable); 216baf5664fSJonas Devlieghere 217b842f2ecSJim Ingham BreakpointName *bp_name = GetBreakpointName(); 218b842f2ecSJim Ingham if (!bp_name) 219b842f2ecSJim Ingham return; 220b842f2ecSJim Ingham 221b842f2ecSJim Ingham std::lock_guard<std::recursive_mutex> guard( 222b842f2ecSJim Ingham m_impl_up->GetTarget()->GetAPIMutex()); 223b842f2ecSJim Ingham 224b842f2ecSJim Ingham bp_name->GetOptions().SetEnabled(enable); 225b842f2ecSJim Ingham } 226b842f2ecSJim Ingham 227b842f2ecSJim Ingham void SBBreakpointName::UpdateName(BreakpointName &bp_name) { 228b842f2ecSJim Ingham if (!IsValid()) 229b842f2ecSJim Ingham return; 230b842f2ecSJim Ingham 231b842f2ecSJim Ingham TargetSP target_sp = m_impl_up->GetTarget(); 232b842f2ecSJim Ingham if (!target_sp) 233b842f2ecSJim Ingham return; 234b842f2ecSJim Ingham target_sp->ApplyNameToBreakpoints(bp_name); 235b842f2ecSJim Ingham 236b842f2ecSJim Ingham } 237b842f2ecSJim Ingham 238b842f2ecSJim Ingham bool SBBreakpointName::IsEnabled() { 239baf5664fSJonas Devlieghere LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, IsEnabled); 240baf5664fSJonas Devlieghere 241b842f2ecSJim Ingham BreakpointName *bp_name = GetBreakpointName(); 242b842f2ecSJim Ingham if (!bp_name) 243b842f2ecSJim Ingham return false; 244b842f2ecSJim Ingham 245b842f2ecSJim Ingham std::lock_guard<std::recursive_mutex> guard( 246b842f2ecSJim Ingham m_impl_up->GetTarget()->GetAPIMutex()); 247b842f2ecSJim Ingham 248b842f2ecSJim Ingham return bp_name->GetOptions().IsEnabled(); 249b842f2ecSJim Ingham } 250b842f2ecSJim Ingham 251b842f2ecSJim Ingham void SBBreakpointName::SetOneShot(bool one_shot) { 252baf5664fSJonas Devlieghere LLDB_RECORD_METHOD(void, SBBreakpointName, SetOneShot, (bool), one_shot); 253baf5664fSJonas Devlieghere 254b842f2ecSJim Ingham BreakpointName *bp_name = GetBreakpointName(); 255b842f2ecSJim Ingham if (!bp_name) 256b842f2ecSJim Ingham return; 257b842f2ecSJim Ingham 258b842f2ecSJim Ingham std::lock_guard<std::recursive_mutex> guard( 259b842f2ecSJim Ingham m_impl_up->GetTarget()->GetAPIMutex()); 260b842f2ecSJim Ingham 261b842f2ecSJim Ingham bp_name->GetOptions().SetOneShot(one_shot); 262b842f2ecSJim Ingham UpdateName(*bp_name); 263b842f2ecSJim Ingham } 264b842f2ecSJim Ingham 265b842f2ecSJim Ingham bool SBBreakpointName::IsOneShot() const { 266baf5664fSJonas Devlieghere LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, IsOneShot); 267baf5664fSJonas Devlieghere 268b842f2ecSJim Ingham const BreakpointName *bp_name = GetBreakpointName(); 269b842f2ecSJim Ingham if (!bp_name) 270b842f2ecSJim Ingham return false; 271b842f2ecSJim Ingham 272b842f2ecSJim Ingham std::lock_guard<std::recursive_mutex> guard( 273b842f2ecSJim Ingham m_impl_up->GetTarget()->GetAPIMutex()); 274b842f2ecSJim Ingham 275b842f2ecSJim Ingham return bp_name->GetOptions().IsOneShot(); 276b842f2ecSJim Ingham } 277b842f2ecSJim Ingham 278b842f2ecSJim Ingham void SBBreakpointName::SetIgnoreCount(uint32_t count) { 279baf5664fSJonas Devlieghere LLDB_RECORD_METHOD(void, SBBreakpointName, SetIgnoreCount, (uint32_t), count); 280baf5664fSJonas Devlieghere 281b842f2ecSJim Ingham BreakpointName *bp_name = GetBreakpointName(); 282b842f2ecSJim Ingham if (!bp_name) 283b842f2ecSJim Ingham return; 284b842f2ecSJim Ingham 285b842f2ecSJim Ingham std::lock_guard<std::recursive_mutex> guard( 286b842f2ecSJim Ingham m_impl_up->GetTarget()->GetAPIMutex()); 287b842f2ecSJim Ingham 288b842f2ecSJim Ingham bp_name->GetOptions().SetIgnoreCount(count); 289b842f2ecSJim Ingham UpdateName(*bp_name); 290b842f2ecSJim Ingham } 291b842f2ecSJim Ingham 292b842f2ecSJim Ingham uint32_t SBBreakpointName::GetIgnoreCount() const { 293baf5664fSJonas Devlieghere LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointName, GetIgnoreCount); 294baf5664fSJonas Devlieghere 295b842f2ecSJim Ingham BreakpointName *bp_name = GetBreakpointName(); 296b842f2ecSJim Ingham if (!bp_name) 297b842f2ecSJim Ingham return false; 298b842f2ecSJim Ingham 299b842f2ecSJim Ingham std::lock_guard<std::recursive_mutex> guard( 300b842f2ecSJim Ingham m_impl_up->GetTarget()->GetAPIMutex()); 301b842f2ecSJim Ingham 302b842f2ecSJim Ingham return bp_name->GetOptions().GetIgnoreCount(); 303b842f2ecSJim Ingham } 304b842f2ecSJim Ingham 305b842f2ecSJim Ingham void SBBreakpointName::SetCondition(const char *condition) { 306baf5664fSJonas Devlieghere LLDB_RECORD_METHOD(void, SBBreakpointName, SetCondition, (const char *), 307baf5664fSJonas Devlieghere condition); 308baf5664fSJonas Devlieghere 309b842f2ecSJim Ingham BreakpointName *bp_name = GetBreakpointName(); 310b842f2ecSJim Ingham if (!bp_name) 311b842f2ecSJim Ingham return; 312b842f2ecSJim Ingham 313b842f2ecSJim Ingham std::lock_guard<std::recursive_mutex> guard( 314b842f2ecSJim Ingham m_impl_up->GetTarget()->GetAPIMutex()); 315b842f2ecSJim Ingham 316b842f2ecSJim Ingham bp_name->GetOptions().SetCondition(condition); 317b842f2ecSJim Ingham UpdateName(*bp_name); 318b842f2ecSJim Ingham } 319b842f2ecSJim Ingham 320b842f2ecSJim Ingham const char *SBBreakpointName::GetCondition() { 321baf5664fSJonas Devlieghere LLDB_RECORD_METHOD_NO_ARGS(const char *, SBBreakpointName, GetCondition); 322baf5664fSJonas Devlieghere 323b842f2ecSJim Ingham BreakpointName *bp_name = GetBreakpointName(); 324b842f2ecSJim Ingham if (!bp_name) 325b842f2ecSJim Ingham return nullptr; 326b842f2ecSJim Ingham 327b842f2ecSJim Ingham std::lock_guard<std::recursive_mutex> guard( 328b842f2ecSJim Ingham m_impl_up->GetTarget()->GetAPIMutex()); 329b842f2ecSJim Ingham 330b842f2ecSJim Ingham return bp_name->GetOptions().GetConditionText(); 331b842f2ecSJim Ingham } 332b842f2ecSJim Ingham 333b842f2ecSJim Ingham void SBBreakpointName::SetAutoContinue(bool auto_continue) { 334baf5664fSJonas Devlieghere LLDB_RECORD_METHOD(void, SBBreakpointName, SetAutoContinue, (bool), 335baf5664fSJonas Devlieghere auto_continue); 336baf5664fSJonas Devlieghere 337b842f2ecSJim Ingham BreakpointName *bp_name = GetBreakpointName(); 338b842f2ecSJim Ingham if (!bp_name) 339b842f2ecSJim Ingham return; 340b842f2ecSJim Ingham 341b842f2ecSJim Ingham std::lock_guard<std::recursive_mutex> guard( 342b842f2ecSJim Ingham m_impl_up->GetTarget()->GetAPIMutex()); 343b842f2ecSJim Ingham 344b842f2ecSJim Ingham bp_name->GetOptions().SetAutoContinue(auto_continue); 345b842f2ecSJim Ingham UpdateName(*bp_name); 346b842f2ecSJim Ingham } 347b842f2ecSJim Ingham 348b842f2ecSJim Ingham bool SBBreakpointName::GetAutoContinue() { 349baf5664fSJonas Devlieghere LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAutoContinue); 350baf5664fSJonas Devlieghere 351b842f2ecSJim Ingham BreakpointName *bp_name = GetBreakpointName(); 352b842f2ecSJim Ingham if (!bp_name) 353576628bdSJim Ingham return false; 354b842f2ecSJim Ingham 355b842f2ecSJim Ingham std::lock_guard<std::recursive_mutex> guard( 356b842f2ecSJim Ingham m_impl_up->GetTarget()->GetAPIMutex()); 357b842f2ecSJim Ingham 358b842f2ecSJim Ingham return bp_name->GetOptions().IsAutoContinue(); 359b842f2ecSJim Ingham } 360b842f2ecSJim Ingham 361b842f2ecSJim Ingham void SBBreakpointName::SetThreadID(tid_t tid) { 362baf5664fSJonas Devlieghere LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadID, (lldb::tid_t), tid); 363baf5664fSJonas Devlieghere 364b842f2ecSJim Ingham BreakpointName *bp_name = GetBreakpointName(); 365b842f2ecSJim Ingham if (!bp_name) 366b842f2ecSJim Ingham return; 367b842f2ecSJim Ingham 368b842f2ecSJim Ingham std::lock_guard<std::recursive_mutex> guard( 369b842f2ecSJim Ingham m_impl_up->GetTarget()->GetAPIMutex()); 370b842f2ecSJim Ingham 371b842f2ecSJim Ingham bp_name->GetOptions().SetThreadID(tid); 372b842f2ecSJim Ingham UpdateName(*bp_name); 373b842f2ecSJim Ingham } 374b842f2ecSJim Ingham 375b842f2ecSJim Ingham tid_t SBBreakpointName::GetThreadID() { 376baf5664fSJonas Devlieghere LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBBreakpointName, GetThreadID); 377baf5664fSJonas Devlieghere 378b842f2ecSJim Ingham BreakpointName *bp_name = GetBreakpointName(); 379b842f2ecSJim Ingham if (!bp_name) 380b842f2ecSJim Ingham return LLDB_INVALID_THREAD_ID; 381b842f2ecSJim Ingham 382b842f2ecSJim Ingham std::lock_guard<std::recursive_mutex> guard( 383b842f2ecSJim Ingham m_impl_up->GetTarget()->GetAPIMutex()); 384b842f2ecSJim Ingham 385b842f2ecSJim Ingham return bp_name->GetOptions().GetThreadSpec()->GetTID(); 386b842f2ecSJim Ingham } 387b842f2ecSJim Ingham 388b842f2ecSJim Ingham void SBBreakpointName::SetThreadIndex(uint32_t index) { 389baf5664fSJonas Devlieghere LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadIndex, (uint32_t), index); 390baf5664fSJonas Devlieghere 391b842f2ecSJim Ingham BreakpointName *bp_name = GetBreakpointName(); 392b842f2ecSJim Ingham if (!bp_name) 393b842f2ecSJim Ingham return; 394b842f2ecSJim Ingham 395b842f2ecSJim Ingham std::lock_guard<std::recursive_mutex> guard( 396b842f2ecSJim Ingham m_impl_up->GetTarget()->GetAPIMutex()); 397b842f2ecSJim Ingham 398b842f2ecSJim Ingham bp_name->GetOptions().GetThreadSpec()->SetIndex(index); 399b842f2ecSJim Ingham UpdateName(*bp_name); 400b842f2ecSJim Ingham } 401b842f2ecSJim Ingham 402b842f2ecSJim Ingham uint32_t SBBreakpointName::GetThreadIndex() const { 403baf5664fSJonas Devlieghere LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointName, GetThreadIndex); 404baf5664fSJonas Devlieghere 405b842f2ecSJim Ingham BreakpointName *bp_name = GetBreakpointName(); 406b842f2ecSJim Ingham if (!bp_name) 407b842f2ecSJim Ingham return LLDB_INVALID_THREAD_ID; 408b842f2ecSJim Ingham 409b842f2ecSJim Ingham std::lock_guard<std::recursive_mutex> guard( 410b842f2ecSJim Ingham m_impl_up->GetTarget()->GetAPIMutex()); 411b842f2ecSJim Ingham 412b842f2ecSJim Ingham return bp_name->GetOptions().GetThreadSpec()->GetIndex(); 413b842f2ecSJim Ingham } 414b842f2ecSJim Ingham 415b842f2ecSJim Ingham void SBBreakpointName::SetThreadName(const char *thread_name) { 416baf5664fSJonas Devlieghere LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadName, (const char *), 417baf5664fSJonas Devlieghere thread_name); 418baf5664fSJonas Devlieghere 419b842f2ecSJim Ingham BreakpointName *bp_name = GetBreakpointName(); 420b842f2ecSJim Ingham if (!bp_name) 421b842f2ecSJim Ingham return; 422b842f2ecSJim Ingham 423b842f2ecSJim Ingham std::lock_guard<std::recursive_mutex> guard( 424b842f2ecSJim Ingham m_impl_up->GetTarget()->GetAPIMutex()); 425b842f2ecSJim Ingham 426b842f2ecSJim Ingham bp_name->GetOptions().GetThreadSpec()->SetName(thread_name); 427b842f2ecSJim Ingham UpdateName(*bp_name); 428b842f2ecSJim Ingham } 429b842f2ecSJim Ingham 430b842f2ecSJim Ingham const char *SBBreakpointName::GetThreadName() const { 431baf5664fSJonas Devlieghere LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName, 432baf5664fSJonas Devlieghere GetThreadName); 433baf5664fSJonas Devlieghere 434b842f2ecSJim Ingham BreakpointName *bp_name = GetBreakpointName(); 435b842f2ecSJim Ingham if (!bp_name) 436b842f2ecSJim Ingham return nullptr; 437b842f2ecSJim Ingham 438b842f2ecSJim Ingham std::lock_guard<std::recursive_mutex> guard( 439b842f2ecSJim Ingham m_impl_up->GetTarget()->GetAPIMutex()); 440b842f2ecSJim Ingham 441b842f2ecSJim Ingham return bp_name->GetOptions().GetThreadSpec()->GetName(); 442b842f2ecSJim Ingham } 443b842f2ecSJim Ingham 444b842f2ecSJim Ingham void SBBreakpointName::SetQueueName(const char *queue_name) { 445baf5664fSJonas Devlieghere LLDB_RECORD_METHOD(void, SBBreakpointName, SetQueueName, (const char *), 446baf5664fSJonas Devlieghere queue_name); 447baf5664fSJonas Devlieghere 448b842f2ecSJim Ingham BreakpointName *bp_name = GetBreakpointName(); 449b842f2ecSJim Ingham if (!bp_name) 450b842f2ecSJim Ingham return; 451b842f2ecSJim Ingham 452b842f2ecSJim Ingham std::lock_guard<std::recursive_mutex> guard( 453b842f2ecSJim Ingham m_impl_up->GetTarget()->GetAPIMutex()); 454b842f2ecSJim Ingham 455b842f2ecSJim Ingham bp_name->GetOptions().GetThreadSpec()->SetQueueName(queue_name); 456b842f2ecSJim Ingham UpdateName(*bp_name); 457b842f2ecSJim Ingham } 458b842f2ecSJim Ingham 459b842f2ecSJim Ingham const char *SBBreakpointName::GetQueueName() const { 460baf5664fSJonas Devlieghere LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName, 461baf5664fSJonas Devlieghere GetQueueName); 462baf5664fSJonas Devlieghere 463b842f2ecSJim Ingham BreakpointName *bp_name = GetBreakpointName(); 464b842f2ecSJim Ingham if (!bp_name) 465b842f2ecSJim Ingham return nullptr; 466b842f2ecSJim Ingham 467b842f2ecSJim Ingham std::lock_guard<std::recursive_mutex> guard( 468b842f2ecSJim Ingham m_impl_up->GetTarget()->GetAPIMutex()); 469b842f2ecSJim Ingham 470b842f2ecSJim Ingham return bp_name->GetOptions().GetThreadSpec()->GetQueueName(); 471b842f2ecSJim Ingham } 472b842f2ecSJim Ingham 473b842f2ecSJim Ingham void SBBreakpointName::SetCommandLineCommands(SBStringList &commands) { 474baf5664fSJonas Devlieghere LLDB_RECORD_METHOD(void, SBBreakpointName, SetCommandLineCommands, 475baf5664fSJonas Devlieghere (lldb::SBStringList &), commands); 476baf5664fSJonas Devlieghere 477b842f2ecSJim Ingham BreakpointName *bp_name = GetBreakpointName(); 478b842f2ecSJim Ingham if (!bp_name) 479b842f2ecSJim Ingham return; 480b842f2ecSJim Ingham if (commands.GetSize() == 0) 481b842f2ecSJim Ingham return; 482b842f2ecSJim Ingham 483b842f2ecSJim Ingham 484b842f2ecSJim Ingham std::lock_guard<std::recursive_mutex> guard( 485b842f2ecSJim Ingham m_impl_up->GetTarget()->GetAPIMutex()); 486b842f2ecSJim Ingham std::unique_ptr<BreakpointOptions::CommandData> cmd_data_up( 487b842f2ecSJim Ingham new BreakpointOptions::CommandData(*commands, eScriptLanguageNone)); 488b842f2ecSJim Ingham 489b842f2ecSJim Ingham bp_name->GetOptions().SetCommandDataCallback(cmd_data_up); 490b842f2ecSJim Ingham UpdateName(*bp_name); 491b842f2ecSJim Ingham } 492b842f2ecSJim Ingham 493b842f2ecSJim Ingham bool SBBreakpointName::GetCommandLineCommands(SBStringList &commands) { 494baf5664fSJonas Devlieghere LLDB_RECORD_METHOD(bool, SBBreakpointName, GetCommandLineCommands, 495baf5664fSJonas Devlieghere (lldb::SBStringList &), commands); 496baf5664fSJonas Devlieghere 497b842f2ecSJim Ingham BreakpointName *bp_name = GetBreakpointName(); 498b842f2ecSJim Ingham if (!bp_name) 499b842f2ecSJim Ingham return false; 500b842f2ecSJim Ingham 501b842f2ecSJim Ingham StringList command_list; 502b842f2ecSJim Ingham bool has_commands = 503b842f2ecSJim Ingham bp_name->GetOptions().GetCommandLineCallbacks(command_list); 504b842f2ecSJim Ingham if (has_commands) 505b842f2ecSJim Ingham commands.AppendList(command_list); 506b842f2ecSJim Ingham return has_commands; 507b842f2ecSJim Ingham } 508b842f2ecSJim Ingham 509e9632ebaSJim Ingham const char *SBBreakpointName::GetHelpString() const { 510baf5664fSJonas Devlieghere LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName, 511baf5664fSJonas Devlieghere GetHelpString); 512baf5664fSJonas Devlieghere 513e9632ebaSJim Ingham BreakpointName *bp_name = GetBreakpointName(); 514e9632ebaSJim Ingham if (!bp_name) 515e9632ebaSJim Ingham return ""; 516e9632ebaSJim Ingham 517e9632ebaSJim Ingham return bp_name->GetHelp(); 518e9632ebaSJim Ingham } 519e9632ebaSJim Ingham 520e9632ebaSJim Ingham void SBBreakpointName::SetHelpString(const char *help_string) { 521baf5664fSJonas Devlieghere LLDB_RECORD_METHOD(void, SBBreakpointName, SetHelpString, (const char *), 522baf5664fSJonas Devlieghere help_string); 523baf5664fSJonas Devlieghere 524e9632ebaSJim Ingham BreakpointName *bp_name = GetBreakpointName(); 525e9632ebaSJim Ingham if (!bp_name) 526e9632ebaSJim Ingham return; 527e9632ebaSJim Ingham 528e9632ebaSJim Ingham 529e9632ebaSJim Ingham std::lock_guard<std::recursive_mutex> guard( 530e9632ebaSJim Ingham m_impl_up->GetTarget()->GetAPIMutex()); 531e9632ebaSJim Ingham bp_name->SetHelp(help_string); 532e9632ebaSJim Ingham } 533e9632ebaSJim Ingham 534b842f2ecSJim Ingham bool SBBreakpointName::GetDescription(SBStream &s) { 535baf5664fSJonas Devlieghere LLDB_RECORD_METHOD(bool, SBBreakpointName, GetDescription, (lldb::SBStream &), 536baf5664fSJonas Devlieghere s); 537baf5664fSJonas Devlieghere 538b842f2ecSJim Ingham BreakpointName *bp_name = GetBreakpointName(); 539b842f2ecSJim Ingham if (!bp_name) 540b842f2ecSJim Ingham { 541b842f2ecSJim Ingham s.Printf("No value"); 542b842f2ecSJim Ingham return false; 543b842f2ecSJim Ingham } 544b842f2ecSJim Ingham 545b842f2ecSJim Ingham std::lock_guard<std::recursive_mutex> guard( 546b842f2ecSJim Ingham m_impl_up->GetTarget()->GetAPIMutex()); 547b842f2ecSJim Ingham bp_name->GetDescription(s.get(), eDescriptionLevelFull); 548b842f2ecSJim Ingham return true; 549b842f2ecSJim Ingham } 550b842f2ecSJim Ingham 551b842f2ecSJim Ingham void SBBreakpointName::SetCallback(SBBreakpointHitCallback callback, 552b842f2ecSJim Ingham void *baton) { 5530d7b0c96SJonas Devlieghere LLDB_RECORD_DUMMY(void, SBBreakpointName, SetCallback, 5540d7b0c96SJonas Devlieghere (lldb::SBBreakpointHitCallback, void *), callback, baton); 5550d7b0c96SJonas Devlieghere 556b842f2ecSJim Ingham BreakpointName *bp_name = GetBreakpointName(); 557b842f2ecSJim Ingham if (!bp_name) 558b842f2ecSJim Ingham return; 559b842f2ecSJim Ingham std::lock_guard<std::recursive_mutex> guard( 560b842f2ecSJim Ingham m_impl_up->GetTarget()->GetAPIMutex()); 561b842f2ecSJim Ingham 562b842f2ecSJim Ingham BatonSP baton_sp(new SBBreakpointCallbackBaton(callback, baton)); 563b842f2ecSJim Ingham bp_name->GetOptions().SetCallback(SBBreakpointCallbackBaton 564b842f2ecSJim Ingham ::PrivateBreakpointHitCallback, 565b842f2ecSJim Ingham baton_sp, 566b842f2ecSJim Ingham false); 567b842f2ecSJim Ingham UpdateName(*bp_name); 568b842f2ecSJim Ingham } 569b842f2ecSJim Ingham 570b842f2ecSJim Ingham void SBBreakpointName::SetScriptCallbackFunction( 571b842f2ecSJim Ingham const char *callback_function_name) { 572baf5664fSJonas Devlieghere LLDB_RECORD_METHOD(void, SBBreakpointName, SetScriptCallbackFunction, 573baf5664fSJonas Devlieghere (const char *), callback_function_name); 574738af7a6SJim Ingham SBStructuredData empty_args; 575738af7a6SJim Ingham SetScriptCallbackFunction(callback_function_name, empty_args); 576738af7a6SJim Ingham } 577baf5664fSJonas Devlieghere 578738af7a6SJim Ingham SBError SBBreakpointName::SetScriptCallbackFunction( 579738af7a6SJim Ingham const char *callback_function_name, 580738af7a6SJim Ingham SBStructuredData &extra_args) { 581738af7a6SJim Ingham LLDB_RECORD_METHOD(SBError, SBBreakpointName, SetScriptCallbackFunction, 582738af7a6SJim Ingham (const char *, SBStructuredData &), 583738af7a6SJim Ingham callback_function_name, extra_args); 584738af7a6SJim Ingham SBError sb_error; 585b842f2ecSJim Ingham BreakpointName *bp_name = GetBreakpointName(); 586738af7a6SJim Ingham if (!bp_name) { 587738af7a6SJim Ingham sb_error.SetErrorString("unrecognized breakpoint name"); 588738af7a6SJim Ingham return LLDB_RECORD_RESULT(sb_error); 589738af7a6SJim Ingham } 590b842f2ecSJim Ingham 591b842f2ecSJim Ingham std::lock_guard<std::recursive_mutex> guard( 592b842f2ecSJim Ingham m_impl_up->GetTarget()->GetAPIMutex()); 593b842f2ecSJim Ingham 594b842f2ecSJim Ingham BreakpointOptions &bp_options = bp_name->GetOptions(); 595738af7a6SJim Ingham Status error; 596738af7a6SJim Ingham error = m_impl_up->GetTarget() 597b842f2ecSJim Ingham ->GetDebugger() 598b842f2ecSJim Ingham .GetScriptInterpreter() 599*cfb96d84SJim Ingham ->SetBreakpointCommandCallbackFunction( 600*cfb96d84SJim Ingham bp_options, callback_function_name, 601*cfb96d84SJim Ingham extra_args.m_impl_up->GetObjectSP()); 602738af7a6SJim Ingham sb_error.SetError(error); 603b842f2ecSJim Ingham UpdateName(*bp_name); 604738af7a6SJim Ingham return LLDB_RECORD_RESULT(sb_error); 605b842f2ecSJim Ingham } 606b842f2ecSJim Ingham 607baf5664fSJonas Devlieghere SBError 608baf5664fSJonas Devlieghere SBBreakpointName::SetScriptCallbackBody(const char *callback_body_text) { 609baf5664fSJonas Devlieghere LLDB_RECORD_METHOD(lldb::SBError, SBBreakpointName, SetScriptCallbackBody, 610baf5664fSJonas Devlieghere (const char *), callback_body_text); 611baf5664fSJonas Devlieghere 612b842f2ecSJim Ingham SBError sb_error; 613b842f2ecSJim Ingham BreakpointName *bp_name = GetBreakpointName(); 614b842f2ecSJim Ingham if (!bp_name) 615baf5664fSJonas Devlieghere return LLDB_RECORD_RESULT(sb_error); 616b842f2ecSJim Ingham 617b842f2ecSJim Ingham std::lock_guard<std::recursive_mutex> guard( 618b842f2ecSJim Ingham m_impl_up->GetTarget()->GetAPIMutex()); 619b842f2ecSJim Ingham 620b842f2ecSJim Ingham BreakpointOptions &bp_options = bp_name->GetOptions(); 621b842f2ecSJim Ingham Status error = 622b842f2ecSJim Ingham m_impl_up->GetTarget() 623b842f2ecSJim Ingham ->GetDebugger() 624b842f2ecSJim Ingham .GetScriptInterpreter() 625*cfb96d84SJim Ingham ->SetBreakpointCommandCallback(bp_options, callback_body_text); 626b842f2ecSJim Ingham sb_error.SetError(error); 627b842f2ecSJim Ingham if (!sb_error.Fail()) 628b842f2ecSJim Ingham UpdateName(*bp_name); 629b842f2ecSJim Ingham 630baf5664fSJonas Devlieghere return LLDB_RECORD_RESULT(sb_error); 631b842f2ecSJim Ingham } 632b842f2ecSJim Ingham 633baf5664fSJonas Devlieghere bool SBBreakpointName::GetAllowList() const { 634baf5664fSJonas Devlieghere LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, GetAllowList); 635baf5664fSJonas Devlieghere 636b842f2ecSJim Ingham BreakpointName *bp_name = GetBreakpointName(); 637b842f2ecSJim Ingham if (!bp_name) 638b842f2ecSJim Ingham return false; 639b842f2ecSJim Ingham return bp_name->GetPermissions().GetAllowList(); 640b842f2ecSJim Ingham } 641b842f2ecSJim Ingham 642baf5664fSJonas Devlieghere void SBBreakpointName::SetAllowList(bool value) { 643baf5664fSJonas Devlieghere LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowList, (bool), value); 644baf5664fSJonas Devlieghere 645b842f2ecSJim Ingham 646b842f2ecSJim Ingham BreakpointName *bp_name = GetBreakpointName(); 647b842f2ecSJim Ingham if (!bp_name) 648b842f2ecSJim Ingham return; 649b842f2ecSJim Ingham bp_name->GetPermissions().SetAllowList(value); 650b842f2ecSJim Ingham } 651b842f2ecSJim Ingham 652baf5664fSJonas Devlieghere bool SBBreakpointName::GetAllowDelete() { 653baf5664fSJonas Devlieghere LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAllowDelete); 654baf5664fSJonas Devlieghere 655b842f2ecSJim Ingham BreakpointName *bp_name = GetBreakpointName(); 656b842f2ecSJim Ingham if (!bp_name) 657b842f2ecSJim Ingham return false; 658b842f2ecSJim Ingham return bp_name->GetPermissions().GetAllowDelete(); 659b842f2ecSJim Ingham } 660b842f2ecSJim Ingham 661baf5664fSJonas Devlieghere void SBBreakpointName::SetAllowDelete(bool value) { 662baf5664fSJonas Devlieghere LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowDelete, (bool), value); 663baf5664fSJonas Devlieghere 664b842f2ecSJim Ingham 665b842f2ecSJim Ingham BreakpointName *bp_name = GetBreakpointName(); 666b842f2ecSJim Ingham if (!bp_name) 667b842f2ecSJim Ingham return; 668b842f2ecSJim Ingham bp_name->GetPermissions().SetAllowDelete(value); 669b842f2ecSJim Ingham } 670b842f2ecSJim Ingham 671baf5664fSJonas Devlieghere bool SBBreakpointName::GetAllowDisable() { 672baf5664fSJonas Devlieghere LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAllowDisable); 673baf5664fSJonas Devlieghere 674b842f2ecSJim Ingham BreakpointName *bp_name = GetBreakpointName(); 675b842f2ecSJim Ingham if (!bp_name) 676b842f2ecSJim Ingham return false; 677b842f2ecSJim Ingham return bp_name->GetPermissions().GetAllowDisable(); 678b842f2ecSJim Ingham } 679b842f2ecSJim Ingham 680baf5664fSJonas Devlieghere void SBBreakpointName::SetAllowDisable(bool value) { 681baf5664fSJonas Devlieghere LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowDisable, (bool), value); 682baf5664fSJonas Devlieghere 683b842f2ecSJim Ingham BreakpointName *bp_name = GetBreakpointName(); 684b842f2ecSJim Ingham if (!bp_name) 685b842f2ecSJim Ingham return; 686b842f2ecSJim Ingham bp_name->GetPermissions().SetAllowDisable(value); 687b842f2ecSJim Ingham } 688b842f2ecSJim Ingham 689b842f2ecSJim Ingham lldb_private::BreakpointName *SBBreakpointName::GetBreakpointName() const 690b842f2ecSJim Ingham { 691b842f2ecSJim Ingham if (!IsValid()) 692b842f2ecSJim Ingham return nullptr; 693b842f2ecSJim Ingham return m_impl_up->GetBreakpointName(); 694b842f2ecSJim Ingham } 695b842f2ecSJim Ingham 696ae211eceSMichal Gorny 697ae211eceSMichal Gorny namespace lldb_private { 698ae211eceSMichal Gorny namespace repro { 699ae211eceSMichal Gorny 700ae211eceSMichal Gorny template <> 701ae211eceSMichal Gorny void RegisterMethods<SBBreakpointName>(Registry &R) { 702ae211eceSMichal Gorny LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName, ()); 703ae211eceSMichal Gorny LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName, 704ae211eceSMichal Gorny (lldb::SBTarget &, const char *)); 705ae211eceSMichal Gorny LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName, 706ae211eceSMichal Gorny (lldb::SBBreakpoint &, const char *)); 707ae211eceSMichal Gorny LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName, 708ae211eceSMichal Gorny (const lldb::SBBreakpointName &)); 709ae211eceSMichal Gorny LLDB_REGISTER_METHOD( 710ae211eceSMichal Gorny const lldb::SBBreakpointName &, 711ae211eceSMichal Gorny SBBreakpointName, operator=,(const lldb::SBBreakpointName &)); 712ae211eceSMichal Gorny LLDB_REGISTER_METHOD( 713ae211eceSMichal Gorny bool, SBBreakpointName, operator==,(const lldb::SBBreakpointName &)); 714ae211eceSMichal Gorny LLDB_REGISTER_METHOD( 715ae211eceSMichal Gorny bool, SBBreakpointName, operator!=,(const lldb::SBBreakpointName &)); 716ae211eceSMichal Gorny LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, IsValid, ()); 717ae211eceSMichal Gorny LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, operator bool, ()); 718ae211eceSMichal Gorny LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetName, ()); 719ae211eceSMichal Gorny LLDB_REGISTER_METHOD(void, SBBreakpointName, SetEnabled, (bool)); 720ae211eceSMichal Gorny LLDB_REGISTER_METHOD(bool, SBBreakpointName, IsEnabled, ()); 721ae211eceSMichal Gorny LLDB_REGISTER_METHOD(void, SBBreakpointName, SetOneShot, (bool)); 722ae211eceSMichal Gorny LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, IsOneShot, ()); 723ae211eceSMichal Gorny LLDB_REGISTER_METHOD(void, SBBreakpointName, SetIgnoreCount, (uint32_t)); 724ae211eceSMichal Gorny LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpointName, GetIgnoreCount, ()); 725ae211eceSMichal Gorny LLDB_REGISTER_METHOD(void, SBBreakpointName, SetCondition, (const char *)); 726ae211eceSMichal Gorny LLDB_REGISTER_METHOD(const char *, SBBreakpointName, GetCondition, ()); 727ae211eceSMichal Gorny LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAutoContinue, (bool)); 728ae211eceSMichal Gorny LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetAutoContinue, ()); 729ae211eceSMichal Gorny LLDB_REGISTER_METHOD(void, SBBreakpointName, SetThreadID, (lldb::tid_t)); 730ae211eceSMichal Gorny LLDB_REGISTER_METHOD(lldb::tid_t, SBBreakpointName, GetThreadID, ()); 731ae211eceSMichal Gorny LLDB_REGISTER_METHOD(void, SBBreakpointName, SetThreadIndex, (uint32_t)); 732ae211eceSMichal Gorny LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpointName, GetThreadIndex, ()); 733ae211eceSMichal Gorny LLDB_REGISTER_METHOD(void, SBBreakpointName, SetThreadName, (const char *)); 734ae211eceSMichal Gorny LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetThreadName, 735ae211eceSMichal Gorny ()); 736ae211eceSMichal Gorny LLDB_REGISTER_METHOD(void, SBBreakpointName, SetQueueName, (const char *)); 737ae211eceSMichal Gorny LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetQueueName, 738ae211eceSMichal Gorny ()); 739ae211eceSMichal Gorny LLDB_REGISTER_METHOD(void, SBBreakpointName, SetCommandLineCommands, 740ae211eceSMichal Gorny (lldb::SBStringList &)); 741ae211eceSMichal Gorny LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetCommandLineCommands, 742ae211eceSMichal Gorny (lldb::SBStringList &)); 743ae211eceSMichal Gorny LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetHelpString, 744ae211eceSMichal Gorny ()); 745ae211eceSMichal Gorny LLDB_REGISTER_METHOD(void, SBBreakpointName, SetHelpString, (const char *)); 746ae211eceSMichal Gorny LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetDescription, 747ae211eceSMichal Gorny (lldb::SBStream &)); 748ae211eceSMichal Gorny LLDB_REGISTER_METHOD(void, SBBreakpointName, SetScriptCallbackFunction, 749ae211eceSMichal Gorny (const char *)); 750738af7a6SJim Ingham LLDB_REGISTER_METHOD(SBError, SBBreakpointName, SetScriptCallbackFunction, 751738af7a6SJim Ingham (const char *, SBStructuredData &)); 752ae211eceSMichal Gorny LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpointName, SetScriptCallbackBody, 753ae211eceSMichal Gorny (const char *)); 754ae211eceSMichal Gorny LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, GetAllowList, ()); 755ae211eceSMichal Gorny LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAllowList, (bool)); 756ae211eceSMichal Gorny LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetAllowDelete, ()); 757ae211eceSMichal Gorny LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAllowDelete, (bool)); 758ae211eceSMichal Gorny LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetAllowDisable, ()); 759ae211eceSMichal Gorny LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAllowDisable, (bool)); 760ae211eceSMichal Gorny } 761ae211eceSMichal Gorny 762ae211eceSMichal Gorny } 763ae211eceSMichal Gorny } 764