SBBreakpoint.cpp | Explore in Territory

//===-- SBBreakpoint.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/SBBreakpoint.h"
#include "lldb/API/SBBreakpointLocation.h"
#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBEvent.h"
#include "lldb/API/SBProcess.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBStringList.h"
#include "lldb/API/SBStructuredData.h"
#include "lldb/API/SBThread.h"
#include "lldb/Utility/Instrumentation.h"

#include "lldb/Breakpoint/Breakpoint.h"
#include "lldb/Breakpoint/BreakpointIDList.h"
#include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Breakpoint/BreakpointResolver.h"
#include "lldb/Breakpoint/BreakpointResolverScripted.h"
#include "lldb/Breakpoint/StoppointCallbackContext.h"
#include "lldb/Core/Address.h"
#include "lldb/Core/Debugger.h"
#include "lldb/Core/StructuredDataImpl.h"
#include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/ScriptInterpreter.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/SectionLoadList.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadSpec.h"
#include "lldb/Utility/Stream.h"

#include "SBBreakpointOptionCommon.h"

#include "lldb/lldb-enumerations.h"

#include "llvm/ADT/STLExtras.h"

usingnamespacelldb;
usingnamespacelldb_private;

SBBreakpoint::SBBreakpoint() { … }

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

SBBreakpoint::SBBreakpoint(const lldb::BreakpointSP &bp_sp)
    : … { … }

SBBreakpoint::~SBBreakpoint() = default;

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

bool SBBreakpoint::operator==(const lldb::SBBreakpoint &rhs) { … }

bool SBBreakpoint::operator!=(const lldb::SBBreakpoint &rhs) { … }

SBTarget SBBreakpoint::GetTarget() const { … }

break_id_t SBBreakpoint::GetID() const { … }

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

void SBBreakpoint::ClearAllBreakpointSites() { … }

SBBreakpointLocation SBBreakpoint::FindLocationByAddress(addr_t vm_addr) { … }

break_id_t SBBreakpoint::FindLocationIDByAddress(addr_t vm_addr) { … }

SBBreakpointLocation SBBreakpoint::FindLocationByID(break_id_t bp_loc_id) { … }

SBBreakpointLocation SBBreakpoint::GetLocationAtIndex(uint32_t index) { … }

void SBBreakpoint::SetEnabled(bool enable) { … }

bool SBBreakpoint::IsEnabled() { … }

void SBBreakpoint::SetOneShot(bool one_shot) { … }

bool SBBreakpoint::IsOneShot() const { … }

bool SBBreakpoint::IsInternal() { … }

void SBBreakpoint::SetIgnoreCount(uint32_t count) { … }

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

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

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

bool SBBreakpoint::GetAutoContinue() { … }

uint32_t SBBreakpoint::GetHitCount() const { … }

uint32_t SBBreakpoint::GetIgnoreCount() const { … }

void SBBreakpoint::SetThreadID(lldb::tid_t tid) { … }

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

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

uint32_t SBBreakpoint::GetThreadIndex() const { … }

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

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

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

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

size_t SBBreakpoint::GetNumResolvedLocations() const { … }

size_t SBBreakpoint::GetNumLocations() const { … }

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

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

bool SBBreakpoint::GetDescription(SBStream &s) { … }

bool SBBreakpoint::GetDescription(SBStream &s, bool include_locations) { … }

SBError SBBreakpoint::AddLocation(SBAddress &address) { … }

SBStructuredData SBBreakpoint::SerializeToStructuredData() { … }

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

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

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

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

bool SBBreakpoint::AddName(const char *new_name) { … }

SBError SBBreakpoint::AddNameWithErrorHandling(const char *new_name) { … }

void SBBreakpoint::RemoveName(const char *name_to_remove) { … }

bool SBBreakpoint::MatchesName(const char *name) { … }

void SBBreakpoint::GetNames(SBStringList &names) { … }

bool SBBreakpoint::EventIsBreakpointEvent(const lldb::SBEvent &event) { … }

BreakpointEventType
SBBreakpoint::GetBreakpointEventTypeFromEvent(const SBEvent &event) { … }

SBBreakpoint SBBreakpoint::GetBreakpointFromEvent(const lldb::SBEvent &event) { … }

SBBreakpointLocation
SBBreakpoint::GetBreakpointLocationAtIndexFromEvent(const lldb::SBEvent &event,
                                                    uint32_t loc_idx) { … }

uint32_t
SBBreakpoint::GetNumBreakpointLocationsFromEvent(const lldb::SBEvent &event) { … }

bool SBBreakpoint::IsHardware() const { … }

BreakpointSP SBBreakpoint::GetSP() const { … }

// This is simple collection of breakpoint id's and their target.
class SBBreakpointListImpl { … };

SBBreakpointList::SBBreakpointList(SBTarget &target)
    : … { … }

SBBreakpointList::~SBBreakpointList() = default;

size_t SBBreakpointList::GetSize() const { … }

SBBreakpoint SBBreakpointList::GetBreakpointAtIndex(size_t idx) { … }

SBBreakpoint SBBreakpointList::FindBreakpointByID(lldb::break_id_t id) { … }

void SBBreakpointList::Append(const SBBreakpoint &sb_bkpt) { … }

void SBBreakpointList::AppendByID(lldb::break_id_t id) { … }

bool SBBreakpointList::AppendIfUnique(const SBBreakpoint &sb_bkpt) { … }

void SBBreakpointList::Clear() { … }

void SBBreakpointList::CopyToBreakpointIDList(
    lldb_private::BreakpointIDList &bp_id_list) { … }
llvm/lldb/source/API/SBBreakpoint.cpp
