BreakpointLocation.cpp | Explore in Territory

//===-- BreakpointLocation.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/Breakpoint/BreakpointLocation.h"
#include "lldb/Breakpoint/BreakpointID.h"
#include "lldb/Breakpoint/StoppointCallbackContext.h"
#include "lldb/Core/Debugger.h"
#include "lldb/Core/Module.h"
#include "lldb/Core/ValueObject.h"
#include "lldb/Expression/DiagnosticManager.h"
#include "lldb/Expression/ExpressionVariable.h"
#include "lldb/Expression/UserExpression.h"
#include "lldb/Symbol/CompileUnit.h"
#include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/TypeSystem.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadSpec.h"
#include "lldb/Utility/LLDBLog.h"
#include "lldb/Utility/Log.h"
#include "lldb/Utility/StreamString.h"

usingnamespacelldb;
usingnamespacelldb_private;

BreakpointLocation::BreakpointLocation(break_id_t loc_id, Breakpoint &owner,
                                       const Address &addr, lldb::tid_t tid,
                                       bool hardware, bool check_for_resolver)
    : … { … }

BreakpointLocation::~BreakpointLocation() { … }

lldb::addr_t BreakpointLocation::GetLoadAddress() const { … }

const BreakpointOptions &BreakpointLocation::GetOptionsSpecifyingKind(
    BreakpointOptions::OptionKind kind) const { … }

Address &BreakpointLocation::GetAddress() { … }

Breakpoint &BreakpointLocation::GetBreakpoint() { … }

Target &BreakpointLocation::GetTarget() { … }

bool BreakpointLocation::IsEnabled() const { … }

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

bool BreakpointLocation::IsAutoContinue() const { … }

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

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

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

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

uint32_t BreakpointLocation::GetThreadIndex() const { … }

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

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

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

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

bool BreakpointLocation::InvokeCallback(StoppointCallbackContext *context) { … }

bool BreakpointLocation::IsCallbackSynchronous() { … }

void BreakpointLocation::SetCallback(BreakpointHitCallback callback,
                                     void *baton, bool is_synchronous) { … }

void BreakpointLocation::SetCallback(BreakpointHitCallback callback,
                                     const BatonSP &baton_sp,
                                     bool is_synchronous) { … }

void BreakpointLocation::ClearCallback() { … }

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

const char *BreakpointLocation::GetConditionText(size_t *hash) const { … }

bool BreakpointLocation::ConditionSaysStop(ExecutionContext &exe_ctx,
                                           Status &error) { … }

uint32_t BreakpointLocation::GetIgnoreCount() const { … }

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

void BreakpointLocation::DecrementIgnoreCount() { … }

bool BreakpointLocation::IgnoreCountShouldStop() { … }

BreakpointOptions &BreakpointLocation::GetLocationOptions() { … }

bool BreakpointLocation::ValidForThisThread(Thread &thread) { … }

// RETURNS - true if we should stop at this breakpoint, false if we
// should continue.  Note, we don't check the thread spec for the breakpoint
// here, since if the breakpoint is not for this thread, then the event won't
// even get reported, so the check is redundant.

bool BreakpointLocation::ShouldStop(StoppointCallbackContext *context) { … }

void BreakpointLocation::BumpHitCount() { … }

void BreakpointLocation::UndoBumpHitCount() { … }

bool BreakpointLocation::IsResolved() const { … }

lldb::BreakpointSiteSP BreakpointLocation::GetBreakpointSite() const { … }

bool BreakpointLocation::ResolveBreakpointSite() { … }

bool BreakpointLocation::SetBreakpointSite(BreakpointSiteSP &bp_site_sp) { … }

bool BreakpointLocation::ClearBreakpointSite() { … }

void BreakpointLocation::GetDescription(Stream *s,
                                        lldb::DescriptionLevel level) { … }

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

void BreakpointLocation::SendBreakpointLocationChangedEvent(
    lldb::BreakpointEventType eventKind) { … }

void BreakpointLocation::SwapLocation(BreakpointLocationSP swap_from) { … }

void BreakpointLocation::SetThreadIDInternal(lldb::tid_t thread_id) { … }
llvm/lldb/source/Breakpoint/BreakpointLocation.cpp
