llvm/lldb/source/Breakpoint/Watchpoint.cpp

//===-- Watchpoint.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/Watchpoint.h"

#include "lldb/Breakpoint/StoppointCallbackContext.h"
#include "lldb/Breakpoint/WatchpointResource.h"
#include "lldb/Core/Value.h"
#include "lldb/Core/ValueObject.h"
#include "lldb/Core/ValueObjectMemory.h"
#include "lldb/DataFormatters/DumpValueObjectOptions.h"
#include "lldb/Expression/UserExpression.h"
#include "lldb/Symbol/TypeSystem.h"
#include "lldb/Target/Process.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"

usingnamespacelldb;
usingnamespacelldb_private;

Watchpoint::Watchpoint(Target &target, lldb::addr_t addr, uint32_t size,
                       const CompilerType *type, bool hardware)
    : … { … }

Watchpoint::~Watchpoint() = default;

// This function is used when "baton" doesn't need to be freed
void Watchpoint::SetCallback(WatchpointHitCallback 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 Watchpoint::SetCallback(WatchpointHitCallback callback,
                             const BatonSP &callback_baton_sp,
                             bool is_synchronous) { … }

bool Watchpoint::SetupVariableWatchpointDisabler(StackFrameSP frame_sp) const { … }

bool Watchpoint::VariableWatchpointDisabler(void *baton,
                                            StoppointCallbackContext *context,
                                            user_id_t break_id,
                                            user_id_t break_loc_id) { … }

void Watchpoint::ClearCallback() { … }

void Watchpoint::SetDeclInfo(const std::string &str) { … }

std::string Watchpoint::GetWatchSpec() { … }

void Watchpoint::SetWatchSpec(const std::string &str) { … }

bool Watchpoint::IsHardware() const { … }

bool Watchpoint::IsWatchVariable() const { … }

void Watchpoint::SetWatchVariable(bool val) { … }

bool Watchpoint::CaptureWatchedValue(const ExecutionContext &exe_ctx) { … }

bool Watchpoint::WatchedValueReportable(const ExecutionContext &exe_ctx) { … }

// RETURNS - true if we should stop at this breakpoint, false if we
// should continue.

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

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

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

// If prefix is nullptr, we display the watch id and ignore the prefix
// altogether.
bool Watchpoint::DumpSnapshots(Stream *s, const char *prefix) const { … }

void Watchpoint::DumpWithLevel(Stream *s,
                               lldb::DescriptionLevel description_level) const { … }

bool Watchpoint::IsEnabled() const { … }

// Within StopInfo.cpp, we purposely turn on the ephemeral mode right before
// temporarily disable the watchpoint in order to perform possible watchpoint
// actions without triggering further watchpoint events. After the temporary
// disabled watchpoint is enabled, we then turn off the ephemeral mode.

void Watchpoint::TurnOnEphemeralMode() { … }

void Watchpoint::TurnOffEphemeralMode() { … }

bool Watchpoint::IsDisabledDuringEphemeralMode() { … }

void Watchpoint::SetEnabled(bool enabled, bool notify) { … }

void Watchpoint::SetWatchpointType(uint32_t type, bool notify) { … }

bool Watchpoint::WatchpointRead() const { … }

bool Watchpoint::WatchpointWrite() const { … }

bool Watchpoint::WatchpointModify() const { … }

uint32_t Watchpoint::GetIgnoreCount() const { … }

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

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

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

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

void Watchpoint::SendWatchpointChangedEvent(
    lldb::WatchpointEventType eventKind) { … }

Watchpoint::WatchpointEventData::WatchpointEventData(
    WatchpointEventType sub_type, const WatchpointSP &new_watchpoint_sp)
    : … { … }

Watchpoint::WatchpointEventData::~WatchpointEventData() = default;

llvm::StringRef Watchpoint::WatchpointEventData::GetFlavorString() { … }

llvm::StringRef Watchpoint::WatchpointEventData::GetFlavor() const { … }

WatchpointSP &Watchpoint::WatchpointEventData::GetWatchpoint() { … }

WatchpointEventType
Watchpoint::WatchpointEventData::GetWatchpointEventType() const { … }

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

const Watchpoint::WatchpointEventData *
Watchpoint::WatchpointEventData::GetEventDataFromEvent(const Event *event) { … }

WatchpointEventType
Watchpoint::WatchpointEventData::GetWatchpointEventTypeFromEvent(
    const EventSP &event_sp) { … }

WatchpointSP Watchpoint::WatchpointEventData::GetWatchpointFromEvent(
    const EventSP &event_sp) { … }