Breakpoint.cpp | Explore in Territory

//===-- Breakpoint.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 "llvm/Support/Casting.h"

#include "lldb/Breakpoint/Breakpoint.h"
#include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Breakpoint/BreakpointLocationCollection.h"
#include "lldb/Breakpoint/BreakpointPrecondition.h"
#include "lldb/Breakpoint/BreakpointResolver.h"
#include "lldb/Breakpoint/BreakpointResolverFileLine.h"
#include "lldb/Core/Address.h"
#include "lldb/Core/Module.h"
#include "lldb/Core/ModuleList.h"
#include "lldb/Core/SearchFilter.h"
#include "lldb/Core/Section.h"
#include "lldb/Symbol/CompileUnit.h"
#include "lldb/Symbol/Function.h"
#include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/SymbolContext.h"
#include "lldb/Target/SectionLoadList.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/ThreadSpec.h"
#include "lldb/Utility/LLDBLog.h"
#include "lldb/Utility/Log.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"

#include <memory>

usingnamespacelldb;
usingnamespacelldb_private;
usingnamespacellvm;

const char *Breakpoint::g_option_names[static_cast<uint32_t>(
    Breakpoint::OptionNames::LastOptionName)]{ … };

// Breakpoint constructor
Breakpoint::Breakpoint(Target &target, SearchFilterSP &filter_sp,
                       BreakpointResolverSP &resolver_sp, bool hardware,
                       bool resolve_indirect_symbols)
    : … { … }

Breakpoint::Breakpoint(Target &new_target, const Breakpoint &source_bp)
    : … { … }

// Destructor
Breakpoint::~Breakpoint() = default;

BreakpointSP Breakpoint::CopyFromBreakpoint(TargetSP new_target,
    const Breakpoint& bp_to_copy_from) { … }

// Serialization
StructuredData::ObjectSP Breakpoint::SerializeToStructuredData() { … }

lldb::BreakpointSP Breakpoint::CreateFromStructuredData(
    TargetSP target_sp, StructuredData::ObjectSP &object_data, Status &error) { … }

bool Breakpoint::SerializedBreakpointMatchesNames(
    StructuredData::ObjectSP &bkpt_object_sp, std::vector<std::string> &names) { … }

const lldb::TargetSP Breakpoint::GetTargetSP() { … }

bool Breakpoint::IsInternal() const { … }

BreakpointLocationSP Breakpoint::AddLocation(const Address &addr,
                                             bool *new_location) { … }

BreakpointLocationSP Breakpoint::FindLocationByAddress(const Address &addr) { … }

break_id_t Breakpoint::FindLocationIDByAddress(const Address &addr) { … }

BreakpointLocationSP Breakpoint::FindLocationByID(break_id_t bp_loc_id) { … }

BreakpointLocationSP Breakpoint::GetLocationAtIndex(size_t index) { … }

void Breakpoint::RemoveInvalidLocations(const ArchSpec &arch) { … }

// For each of the overall options we need to decide how they propagate to the
// location options.  This will determine the precedence of options on the
// breakpoint vs. its locations.

// Disable at the breakpoint level should override the location settings. That
// way you can conveniently turn off a whole breakpoint without messing up the
// individual settings.

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

bool Breakpoint::IsEnabled() { … }

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

void Breakpoint::DecrementIgnoreCount() { … }

uint32_t Breakpoint::GetIgnoreCount() const { … }

uint32_t Breakpoint::GetHitCount() const { … }

void Breakpoint::ResetHitCount() { … }

bool Breakpoint::IsOneShot() const { … }

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

bool Breakpoint::IsAutoContinue() const { … }

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

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

lldb::tid_t Breakpoint::GetThreadID() const { … }

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

uint32_t Breakpoint::GetThreadIndex() const { … }

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

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

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

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

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

const char *Breakpoint::GetConditionText() const { … }

// This function is used when "baton" doesn't need to be freed
void Breakpoint::SetCallback(BreakpointHitCallback callback, void *baton,
                             bool is_synchronous) { … }

// This function is used when a baton needs to be freed and therefore is
// contained in a "Baton" subclass.
void Breakpoint::SetCallback(BreakpointHitCallback callback,
                             const BatonSP &callback_baton_sp,
                             bool is_synchronous) { … }

void Breakpoint::ClearCallback() { … }

bool Breakpoint::InvokeCallback(StoppointCallbackContext *context,
                                break_id_t bp_loc_id) { … }

BreakpointOptions &Breakpoint::GetOptions() { … }

const BreakpointOptions &Breakpoint::GetOptions() const { … }

void Breakpoint::ResolveBreakpoint() { … }

void Breakpoint::ResolveBreakpointInModules(
    ModuleList &module_list, BreakpointLocationCollection &new_locations) { … }

void Breakpoint::ResolveBreakpointInModules(ModuleList &module_list,
                                            bool send_event) { … }

void Breakpoint::ClearAllBreakpointSites() { … }

// ModulesChanged: Pass in a list of new modules, and

void Breakpoint::ModulesChanged(ModuleList &module_list, bool load,
                                bool delete_locations) { … }

static bool SymbolContextsMightBeEquivalent(SymbolContext &old_sc,
                                            SymbolContext &new_sc) { … }

void Breakpoint::ModuleReplaced(ModuleSP old_module_sp,
                                ModuleSP new_module_sp) { … }

void Breakpoint::Dump(Stream *) { … }

size_t Breakpoint::GetNumResolvedLocations() const { … }

bool Breakpoint::HasResolvedLocations() const { … }

size_t Breakpoint::GetNumLocations() const { … }

void Breakpoint::AddName(llvm::StringRef new_name) { … }

void Breakpoint::GetDescription(Stream *s, lldb::DescriptionLevel level,
                                bool show_locations) { … }

void Breakpoint::GetResolverDescription(Stream *s) { … }

bool Breakpoint::GetMatchingFileLine(ConstString filename,
                                     uint32_t line_number,
                                     BreakpointLocationCollection &loc_coll) { … }

void Breakpoint::GetFilterDescription(Stream *s) { … }

bool Breakpoint::EvaluatePrecondition(StoppointCallbackContext &context) { … }

void Breakpoint::SendBreakpointChangedEvent(
    lldb::BreakpointEventType eventKind) { … }

void Breakpoint::SendBreakpointChangedEvent(
    const lldb::EventDataSP &breakpoint_data_sp) { … }

const char *Breakpoint::BreakpointEventTypeAsCString(BreakpointEventType type) { … }

Log *Breakpoint::BreakpointEventData::GetLogChannel() { … }

Breakpoint::BreakpointEventData::BreakpointEventData(
    BreakpointEventType sub_type, const BreakpointSP &new_breakpoint_sp)
    : … { … }

Breakpoint::BreakpointEventData::~BreakpointEventData() = default;

llvm::StringRef Breakpoint::BreakpointEventData::GetFlavorString() { … }

llvm::StringRef Breakpoint::BreakpointEventData::GetFlavor() const { … }

BreakpointSP Breakpoint::BreakpointEventData::GetBreakpoint() const { … }

BreakpointEventType
Breakpoint::BreakpointEventData::GetBreakpointEventType() const { … }

void Breakpoint::BreakpointEventData::Dump(Stream *s) const { … }

const Breakpoint::BreakpointEventData *
Breakpoint::BreakpointEventData::GetEventDataFromEvent(const Event *event) { … }

BreakpointEventType
Breakpoint::BreakpointEventData::GetBreakpointEventTypeFromEvent(
    const EventSP &event_sp) { … }

BreakpointSP Breakpoint::BreakpointEventData::GetBreakpointFromEvent(
    const EventSP &event_sp) { … }

size_t Breakpoint::BreakpointEventData::GetNumBreakpointLocationsFromEvent(
    const EventSP &event_sp) { … }

lldb::BreakpointLocationSP
Breakpoint::BreakpointEventData::GetBreakpointLocationAtIndexFromEvent(
    const lldb::EventSP &event_sp, uint32_t bp_loc_idx) { … }

json::Value Breakpoint::GetStatistics() { … }
llvm/lldb/source/Breakpoint/Breakpoint.cpp
