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