mirror of
https://github.com/llvm/llvm-project.git
synced 2025-05-03 09:26:06 +00:00
738af7a624
For example, it is pretty easy to write a breakpoint command that implements "stop when my caller is Foo", and
it is pretty easy to write a breakpoint command that implements "stop when my caller is Bar". But there's no
way to write a generic "stop when my caller is..." function, and then specify the caller when you add the
command to a breakpoint.
With this patch, you can pass this data in a SBStructuredData dictionary. That will get stored in
the PythonCommandBaton for the breakpoint, and passed to the implementation function (if it has the right
signature) when the breakpoint is hit. Then in lldb, you can say:
(lldb) break com add -F caller_is -k caller_name -v Foo
More generally this will allow us to write reusable Python breakpoint commands.
Differential Revision: https://reviews.llvm.org/D68671
535 lines
18 KiB
C++
535 lines
18 KiB
C++
//===-- SBBreakpointLocation.cpp --------------------------------*- C++ -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lldb/API/SBBreakpointLocation.h"
|
|
#include "SBReproducerPrivate.h"
|
|
#include "lldb/API/SBAddress.h"
|
|
#include "lldb/API/SBDebugger.h"
|
|
#include "lldb/API/SBDefines.h"
|
|
#include "lldb/API/SBStream.h"
|
|
#include "lldb/API/SBStructuredData.h"
|
|
#include "lldb/API/SBStringList.h"
|
|
|
|
#include "lldb/Breakpoint/Breakpoint.h"
|
|
#include "lldb/Breakpoint/BreakpointLocation.h"
|
|
#include "lldb/Core/Debugger.h"
|
|
#include "lldb/Core/StreamFile.h"
|
|
#include "lldb/Core/StructuredDataImpl.h"
|
|
#include "lldb/Interpreter/CommandInterpreter.h"
|
|
#include "lldb/Interpreter/ScriptInterpreter.h"
|
|
#include "lldb/Target/Target.h"
|
|
#include "lldb/Target/ThreadSpec.h"
|
|
#include "lldb/Utility/Stream.h"
|
|
#include "lldb/lldb-defines.h"
|
|
#include "lldb/lldb-types.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
SBBreakpointLocation::SBBreakpointLocation() {
|
|
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBreakpointLocation);
|
|
}
|
|
|
|
SBBreakpointLocation::SBBreakpointLocation(
|
|
const lldb::BreakpointLocationSP &break_loc_sp)
|
|
: m_opaque_wp(break_loc_sp) {
|
|
LLDB_RECORD_CONSTRUCTOR(SBBreakpointLocation,
|
|
(const lldb::BreakpointLocationSP &), break_loc_sp);
|
|
}
|
|
|
|
SBBreakpointLocation::SBBreakpointLocation(const SBBreakpointLocation &rhs)
|
|
: m_opaque_wp(rhs.m_opaque_wp) {
|
|
LLDB_RECORD_CONSTRUCTOR(SBBreakpointLocation,
|
|
(const lldb::SBBreakpointLocation &), rhs);
|
|
}
|
|
|
|
const SBBreakpointLocation &SBBreakpointLocation::
|
|
operator=(const SBBreakpointLocation &rhs) {
|
|
LLDB_RECORD_METHOD(
|
|
const lldb::SBBreakpointLocation &,
|
|
SBBreakpointLocation, operator=,(const lldb::SBBreakpointLocation &),
|
|
rhs);
|
|
|
|
m_opaque_wp = rhs.m_opaque_wp;
|
|
return LLDB_RECORD_RESULT(*this);
|
|
}
|
|
|
|
SBBreakpointLocation::~SBBreakpointLocation() {}
|
|
|
|
BreakpointLocationSP SBBreakpointLocation::GetSP() const {
|
|
return m_opaque_wp.lock();
|
|
}
|
|
|
|
bool SBBreakpointLocation::IsValid() const {
|
|
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointLocation, IsValid);
|
|
return this->operator bool();
|
|
}
|
|
SBBreakpointLocation::operator bool() const {
|
|
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointLocation, operator bool);
|
|
|
|
return bool(GetSP());
|
|
}
|
|
|
|
SBAddress SBBreakpointLocation::GetAddress() {
|
|
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBBreakpointLocation, GetAddress);
|
|
|
|
BreakpointLocationSP loc_sp = GetSP();
|
|
if (loc_sp) {
|
|
return LLDB_RECORD_RESULT(SBAddress(&loc_sp->GetAddress()));
|
|
}
|
|
|
|
return LLDB_RECORD_RESULT(SBAddress());
|
|
}
|
|
|
|
addr_t SBBreakpointLocation::GetLoadAddress() {
|
|
LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBBreakpointLocation,
|
|
GetLoadAddress);
|
|
|
|
addr_t ret_addr = LLDB_INVALID_ADDRESS;
|
|
BreakpointLocationSP loc_sp = GetSP();
|
|
|
|
if (loc_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
loc_sp->GetTarget().GetAPIMutex());
|
|
ret_addr = loc_sp->GetLoadAddress();
|
|
}
|
|
|
|
return ret_addr;
|
|
}
|
|
|
|
void SBBreakpointLocation::SetEnabled(bool enabled) {
|
|
LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetEnabled, (bool), enabled);
|
|
|
|
BreakpointLocationSP loc_sp = GetSP();
|
|
if (loc_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
loc_sp->GetTarget().GetAPIMutex());
|
|
loc_sp->SetEnabled(enabled);
|
|
}
|
|
}
|
|
|
|
bool SBBreakpointLocation::IsEnabled() {
|
|
LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointLocation, IsEnabled);
|
|
|
|
BreakpointLocationSP loc_sp = GetSP();
|
|
if (loc_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
loc_sp->GetTarget().GetAPIMutex());
|
|
return loc_sp->IsEnabled();
|
|
} else
|
|
return false;
|
|
}
|
|
|
|
uint32_t SBBreakpointLocation::GetHitCount() {
|
|
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBBreakpointLocation, GetHitCount);
|
|
|
|
BreakpointLocationSP loc_sp = GetSP();
|
|
if (loc_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
loc_sp->GetTarget().GetAPIMutex());
|
|
return loc_sp->GetHitCount();
|
|
} else
|
|
return 0;
|
|
}
|
|
|
|
uint32_t SBBreakpointLocation::GetIgnoreCount() {
|
|
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBBreakpointLocation, GetIgnoreCount);
|
|
|
|
BreakpointLocationSP loc_sp = GetSP();
|
|
if (loc_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
loc_sp->GetTarget().GetAPIMutex());
|
|
return loc_sp->GetIgnoreCount();
|
|
} else
|
|
return 0;
|
|
}
|
|
|
|
void SBBreakpointLocation::SetIgnoreCount(uint32_t n) {
|
|
LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetIgnoreCount, (uint32_t), n);
|
|
|
|
BreakpointLocationSP loc_sp = GetSP();
|
|
if (loc_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
loc_sp->GetTarget().GetAPIMutex());
|
|
loc_sp->SetIgnoreCount(n);
|
|
}
|
|
}
|
|
|
|
void SBBreakpointLocation::SetCondition(const char *condition) {
|
|
LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetCondition, (const char *),
|
|
condition);
|
|
|
|
BreakpointLocationSP loc_sp = GetSP();
|
|
if (loc_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
loc_sp->GetTarget().GetAPIMutex());
|
|
loc_sp->SetCondition(condition);
|
|
}
|
|
}
|
|
|
|
const char *SBBreakpointLocation::GetCondition() {
|
|
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBBreakpointLocation, GetCondition);
|
|
|
|
BreakpointLocationSP loc_sp = GetSP();
|
|
if (loc_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
loc_sp->GetTarget().GetAPIMutex());
|
|
return loc_sp->GetConditionText();
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void SBBreakpointLocation::SetAutoContinue(bool auto_continue) {
|
|
LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetAutoContinue, (bool),
|
|
auto_continue);
|
|
|
|
BreakpointLocationSP loc_sp = GetSP();
|
|
if (loc_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
loc_sp->GetTarget().GetAPIMutex());
|
|
loc_sp->SetAutoContinue(auto_continue);
|
|
}
|
|
}
|
|
|
|
bool SBBreakpointLocation::GetAutoContinue() {
|
|
LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointLocation, GetAutoContinue);
|
|
|
|
BreakpointLocationSP loc_sp = GetSP();
|
|
if (loc_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
loc_sp->GetTarget().GetAPIMutex());
|
|
return loc_sp->IsAutoContinue();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void SBBreakpointLocation::SetScriptCallbackFunction(
|
|
const char *callback_function_name) {
|
|
LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetScriptCallbackFunction,
|
|
(const char *), callback_function_name);
|
|
}
|
|
|
|
SBError SBBreakpointLocation::SetScriptCallbackFunction(
|
|
const char *callback_function_name,
|
|
SBStructuredData &extra_args) {
|
|
LLDB_RECORD_METHOD(SBError, SBBreakpointLocation, SetScriptCallbackFunction,
|
|
(const char *, SBStructuredData &),
|
|
callback_function_name, extra_args);
|
|
SBError sb_error;
|
|
BreakpointLocationSP loc_sp = GetSP();
|
|
|
|
if (loc_sp) {
|
|
Status error;
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
loc_sp->GetTarget().GetAPIMutex());
|
|
BreakpointOptions *bp_options = loc_sp->GetLocationOptions();
|
|
error = loc_sp->GetBreakpoint()
|
|
.GetTarget()
|
|
.GetDebugger()
|
|
.GetScriptInterpreter()
|
|
->SetBreakpointCommandCallbackFunction(bp_options,
|
|
callback_function_name,
|
|
extra_args.m_impl_up
|
|
->GetObjectSP());
|
|
sb_error.SetError(error);
|
|
} else
|
|
sb_error.SetErrorString("invalid breakpoint");
|
|
|
|
return LLDB_RECORD_RESULT(sb_error);
|
|
}
|
|
|
|
SBError
|
|
SBBreakpointLocation::SetScriptCallbackBody(const char *callback_body_text) {
|
|
LLDB_RECORD_METHOD(lldb::SBError, SBBreakpointLocation, SetScriptCallbackBody,
|
|
(const char *), callback_body_text);
|
|
|
|
BreakpointLocationSP loc_sp = GetSP();
|
|
|
|
SBError sb_error;
|
|
if (loc_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
loc_sp->GetTarget().GetAPIMutex());
|
|
BreakpointOptions *bp_options = loc_sp->GetLocationOptions();
|
|
Status error =
|
|
loc_sp->GetBreakpoint()
|
|
.GetTarget()
|
|
.GetDebugger()
|
|
.GetScriptInterpreter()
|
|
->SetBreakpointCommandCallback(bp_options, callback_body_text);
|
|
sb_error.SetError(error);
|
|
} else
|
|
sb_error.SetErrorString("invalid breakpoint");
|
|
|
|
return LLDB_RECORD_RESULT(sb_error);
|
|
}
|
|
|
|
void SBBreakpointLocation::SetCommandLineCommands(SBStringList &commands) {
|
|
LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetCommandLineCommands,
|
|
(lldb::SBStringList &), commands);
|
|
|
|
BreakpointLocationSP loc_sp = GetSP();
|
|
if (!loc_sp)
|
|
return;
|
|
if (commands.GetSize() == 0)
|
|
return;
|
|
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
loc_sp->GetTarget().GetAPIMutex());
|
|
std::unique_ptr<BreakpointOptions::CommandData> cmd_data_up(
|
|
new BreakpointOptions::CommandData(*commands, eScriptLanguageNone));
|
|
|
|
loc_sp->GetLocationOptions()->SetCommandDataCallback(cmd_data_up);
|
|
}
|
|
|
|
bool SBBreakpointLocation::GetCommandLineCommands(SBStringList &commands) {
|
|
LLDB_RECORD_METHOD(bool, SBBreakpointLocation, GetCommandLineCommands,
|
|
(lldb::SBStringList &), commands);
|
|
|
|
BreakpointLocationSP loc_sp = GetSP();
|
|
if (!loc_sp)
|
|
return false;
|
|
StringList command_list;
|
|
bool has_commands =
|
|
loc_sp->GetLocationOptions()->GetCommandLineCallbacks(command_list);
|
|
if (has_commands)
|
|
commands.AppendList(command_list);
|
|
return has_commands;
|
|
}
|
|
|
|
void SBBreakpointLocation::SetThreadID(tid_t thread_id) {
|
|
LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetThreadID, (lldb::tid_t),
|
|
thread_id);
|
|
|
|
BreakpointLocationSP loc_sp = GetSP();
|
|
if (loc_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
loc_sp->GetTarget().GetAPIMutex());
|
|
loc_sp->SetThreadID(thread_id);
|
|
}
|
|
}
|
|
|
|
tid_t SBBreakpointLocation::GetThreadID() {
|
|
LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBBreakpointLocation, GetThreadID);
|
|
|
|
tid_t tid = LLDB_INVALID_THREAD_ID;
|
|
BreakpointLocationSP loc_sp = GetSP();
|
|
if (loc_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
loc_sp->GetTarget().GetAPIMutex());
|
|
return loc_sp->GetThreadID();
|
|
}
|
|
return tid;
|
|
}
|
|
|
|
void SBBreakpointLocation::SetThreadIndex(uint32_t index) {
|
|
LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetThreadIndex, (uint32_t),
|
|
index);
|
|
|
|
BreakpointLocationSP loc_sp = GetSP();
|
|
if (loc_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
loc_sp->GetTarget().GetAPIMutex());
|
|
loc_sp->SetThreadIndex(index);
|
|
}
|
|
}
|
|
|
|
uint32_t SBBreakpointLocation::GetThreadIndex() const {
|
|
LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointLocation,
|
|
GetThreadIndex);
|
|
|
|
uint32_t thread_idx = UINT32_MAX;
|
|
BreakpointLocationSP loc_sp = GetSP();
|
|
if (loc_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
loc_sp->GetTarget().GetAPIMutex());
|
|
return loc_sp->GetThreadIndex();
|
|
}
|
|
return thread_idx;
|
|
}
|
|
|
|
void SBBreakpointLocation::SetThreadName(const char *thread_name) {
|
|
LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetThreadName, (const char *),
|
|
thread_name);
|
|
|
|
BreakpointLocationSP loc_sp = GetSP();
|
|
if (loc_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
loc_sp->GetTarget().GetAPIMutex());
|
|
loc_sp->SetThreadName(thread_name);
|
|
}
|
|
}
|
|
|
|
const char *SBBreakpointLocation::GetThreadName() const {
|
|
LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointLocation,
|
|
GetThreadName);
|
|
|
|
BreakpointLocationSP loc_sp = GetSP();
|
|
if (loc_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
loc_sp->GetTarget().GetAPIMutex());
|
|
return loc_sp->GetThreadName();
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void SBBreakpointLocation::SetQueueName(const char *queue_name) {
|
|
LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetQueueName, (const char *),
|
|
queue_name);
|
|
|
|
BreakpointLocationSP loc_sp = GetSP();
|
|
if (loc_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
loc_sp->GetTarget().GetAPIMutex());
|
|
loc_sp->SetQueueName(queue_name);
|
|
}
|
|
}
|
|
|
|
const char *SBBreakpointLocation::GetQueueName() const {
|
|
LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointLocation,
|
|
GetQueueName);
|
|
|
|
BreakpointLocationSP loc_sp = GetSP();
|
|
if (loc_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
loc_sp->GetTarget().GetAPIMutex());
|
|
loc_sp->GetQueueName();
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
bool SBBreakpointLocation::IsResolved() {
|
|
LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointLocation, IsResolved);
|
|
|
|
BreakpointLocationSP loc_sp = GetSP();
|
|
if (loc_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
loc_sp->GetTarget().GetAPIMutex());
|
|
return loc_sp->IsResolved();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void SBBreakpointLocation::SetLocation(
|
|
const lldb::BreakpointLocationSP &break_loc_sp) {
|
|
// Uninstall the callbacks?
|
|
m_opaque_wp = break_loc_sp;
|
|
}
|
|
|
|
bool SBBreakpointLocation::GetDescription(SBStream &description,
|
|
DescriptionLevel level) {
|
|
LLDB_RECORD_METHOD(bool, SBBreakpointLocation, GetDescription,
|
|
(lldb::SBStream &, lldb::DescriptionLevel), description,
|
|
level);
|
|
|
|
Stream &strm = description.ref();
|
|
BreakpointLocationSP loc_sp = GetSP();
|
|
|
|
if (loc_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
loc_sp->GetTarget().GetAPIMutex());
|
|
loc_sp->GetDescription(&strm, level);
|
|
strm.EOL();
|
|
} else
|
|
strm.PutCString("No value");
|
|
|
|
return true;
|
|
}
|
|
|
|
break_id_t SBBreakpointLocation::GetID() {
|
|
LLDB_RECORD_METHOD_NO_ARGS(lldb::break_id_t, SBBreakpointLocation, GetID);
|
|
|
|
BreakpointLocationSP loc_sp = GetSP();
|
|
if (loc_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
loc_sp->GetTarget().GetAPIMutex());
|
|
return loc_sp->GetID();
|
|
} else
|
|
return LLDB_INVALID_BREAK_ID;
|
|
}
|
|
|
|
SBBreakpoint SBBreakpointLocation::GetBreakpoint() {
|
|
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBreakpoint, SBBreakpointLocation,
|
|
GetBreakpoint);
|
|
|
|
BreakpointLocationSP loc_sp = GetSP();
|
|
|
|
SBBreakpoint sb_bp;
|
|
if (loc_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
loc_sp->GetTarget().GetAPIMutex());
|
|
sb_bp = loc_sp->GetBreakpoint().shared_from_this();
|
|
}
|
|
|
|
return LLDB_RECORD_RESULT(sb_bp);
|
|
}
|
|
|
|
namespace lldb_private {
|
|
namespace repro {
|
|
|
|
template <>
|
|
void RegisterMethods<SBBreakpointLocation>(Registry &R) {
|
|
LLDB_REGISTER_CONSTRUCTOR(SBBreakpointLocation, ());
|
|
LLDB_REGISTER_CONSTRUCTOR(SBBreakpointLocation,
|
|
(const lldb::BreakpointLocationSP &));
|
|
LLDB_REGISTER_CONSTRUCTOR(SBBreakpointLocation,
|
|
(const lldb::SBBreakpointLocation &));
|
|
LLDB_REGISTER_METHOD(
|
|
const lldb::SBBreakpointLocation &,
|
|
SBBreakpointLocation, operator=,(const lldb::SBBreakpointLocation &));
|
|
LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointLocation, IsValid, ());
|
|
LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointLocation, operator bool, ());
|
|
LLDB_REGISTER_METHOD(lldb::SBAddress, SBBreakpointLocation, GetAddress, ());
|
|
LLDB_REGISTER_METHOD(lldb::addr_t, SBBreakpointLocation, GetLoadAddress,
|
|
());
|
|
LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetEnabled, (bool));
|
|
LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, IsEnabled, ());
|
|
LLDB_REGISTER_METHOD(uint32_t, SBBreakpointLocation, GetHitCount, ());
|
|
LLDB_REGISTER_METHOD(uint32_t, SBBreakpointLocation, GetIgnoreCount, ());
|
|
LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetIgnoreCount,
|
|
(uint32_t));
|
|
LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetCondition,
|
|
(const char *));
|
|
LLDB_REGISTER_METHOD(const char *, SBBreakpointLocation, GetCondition, ());
|
|
LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetAutoContinue, (bool));
|
|
LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, GetAutoContinue, ());
|
|
LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetScriptCallbackFunction,
|
|
(const char *));
|
|
LLDB_REGISTER_METHOD(SBError, SBBreakpointLocation, SetScriptCallbackFunction,
|
|
(const char *, SBStructuredData &));
|
|
LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpointLocation,
|
|
SetScriptCallbackBody, (const char *));
|
|
LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetCommandLineCommands,
|
|
(lldb::SBStringList &));
|
|
LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, GetCommandLineCommands,
|
|
(lldb::SBStringList &));
|
|
LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetThreadID,
|
|
(lldb::tid_t));
|
|
LLDB_REGISTER_METHOD(lldb::tid_t, SBBreakpointLocation, GetThreadID, ());
|
|
LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetThreadIndex,
|
|
(uint32_t));
|
|
LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpointLocation, GetThreadIndex,
|
|
());
|
|
LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetThreadName,
|
|
(const char *));
|
|
LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointLocation,
|
|
GetThreadName, ());
|
|
LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetQueueName,
|
|
(const char *));
|
|
LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointLocation, GetQueueName,
|
|
());
|
|
LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, IsResolved, ());
|
|
LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, GetDescription,
|
|
(lldb::SBStream &, lldb::DescriptionLevel));
|
|
LLDB_REGISTER_METHOD(lldb::break_id_t, SBBreakpointLocation, GetID, ());
|
|
LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBBreakpointLocation,
|
|
GetBreakpoint, ());
|
|
}
|
|
|
|
}
|
|
}
|