SBBreakpointLocation.cpp | Explore in Territory

//===-- SBBreakpointLocation.cpp ------------------------------------------===//
//
// 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 "lldb/API/SBAddress.h"
#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBDefines.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBStringList.h"
#include "lldb/API/SBStructuredData.h"
#include "lldb/Utility/Instrumentation.h"

#include "lldb/Breakpoint/Breakpoint.h"
#include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Core/Debugger.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"

#include "SBBreakpointOptionCommon.h"

usingnamespacelldb;
usingnamespacelldb_private;

SBBreakpointLocation::SBBreakpointLocation() { … }

SBBreakpointLocation::SBBreakpointLocation(
    const lldb::BreakpointLocationSP &break_loc_sp)
    : … { … }

SBBreakpointLocation::SBBreakpointLocation(const SBBreakpointLocation &rhs)
    : … { … }

const SBBreakpointLocation &SBBreakpointLocation::
operator=(const SBBreakpointLocation &rhs) { … }

SBBreakpointLocation::~SBBreakpointLocation() = default;

BreakpointLocationSP SBBreakpointLocation::GetSP() const { … }

bool SBBreakpointLocation::IsValid() const { … }
operator bool()

SBAddress SBBreakpointLocation::GetAddress() { … }

addr_t SBBreakpointLocation::GetLoadAddress() { … }

void SBBreakpointLocation::SetEnabled(bool enabled) { … }

bool SBBreakpointLocation::IsEnabled() { … }

uint32_t SBBreakpointLocation::GetHitCount() { … }

uint32_t SBBreakpointLocation::GetIgnoreCount() { … }

void SBBreakpointLocation::SetIgnoreCount(uint32_t n) { … }

void SBBreakpointLocation::SetCondition(const char *condition) { … }

const char *SBBreakpointLocation::GetCondition() { … }

void SBBreakpointLocation::SetAutoContinue(bool auto_continue) { … }

bool SBBreakpointLocation::GetAutoContinue() { … }

void SBBreakpointLocation::SetCallback(SBBreakpointHitCallback callback,
                                       void *baton) { … }

void SBBreakpointLocation::SetScriptCallbackFunction(
  const char *callback_function_name) { … }

SBError SBBreakpointLocation::SetScriptCallbackFunction(
    const char *callback_function_name,
    SBStructuredData &extra_args) { … }

SBError
SBBreakpointLocation::SetScriptCallbackBody(const char *callback_body_text) { … }

void SBBreakpointLocation::SetCommandLineCommands(SBStringList &commands) { … }

bool SBBreakpointLocation::GetCommandLineCommands(SBStringList &commands) { … }

void SBBreakpointLocation::SetThreadID(lldb::tid_t thread_id) { … }

lldb::tid_t SBBreakpointLocation::GetThreadID() { … }

void SBBreakpointLocation::SetThreadIndex(uint32_t index) { … }

uint32_t SBBreakpointLocation::GetThreadIndex() const { … }

void SBBreakpointLocation::SetThreadName(const char *thread_name) { … }

const char *SBBreakpointLocation::GetThreadName() const { … }

void SBBreakpointLocation::SetQueueName(const char *queue_name) { … }

const char *SBBreakpointLocation::GetQueueName() const { … }

bool SBBreakpointLocation::IsResolved() { … }

void SBBreakpointLocation::SetLocation(
    const lldb::BreakpointLocationSP &break_loc_sp) { … }

bool SBBreakpointLocation::GetDescription(SBStream &description,
                                          DescriptionLevel level) { … }

break_id_t SBBreakpointLocation::GetID() { … }

SBBreakpoint SBBreakpointLocation::GetBreakpoint() { … }
llvm/lldb/source/API/SBBreakpointLocation.cpp
