LLDB mainline
Watchpoint.cpp
Go to the documentation of this file.
1//===-- Watchpoint.cpp ----------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
10
12#include "lldb/Core/Value.h"
17#include "lldb/Target/Process.h"
18#include "lldb/Target/Target.h"
21#include "lldb/Utility/Log.h"
22#include "lldb/Utility/Stream.h"
23
24using namespace lldb;
25using namespace lldb_private;
26
27Watchpoint::Watchpoint(Target &target, lldb::addr_t addr, uint32_t size,
28 const CompilerType *type, bool hardware)
29 : StoppointSite(0, addr, size, hardware), m_target(target),
30 m_enabled(false), m_is_hardware(hardware), m_is_watch_variable(false),
31 m_is_ephemeral(false), m_disabled_count(0), m_watch_read(0),
32 m_watch_write(0), m_watch_modify(0), m_ignore_count(0),
33 m_being_created(true) {
34
35 if (type && type->IsValid())
36 m_type = *type;
37 else {
38 // If we don't have a known type, then we force it to unsigned int of the
39 // right size.
40 auto type_system_or_err =
42 if (auto err = type_system_or_err.takeError()) {
44 "Failed to set type: {0}");
45 } else {
46 if (auto ts = *type_system_or_err)
47 m_type =
48 ts->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 8 * size);
49 else
51 "Failed to set type: Typesystem is no longer live: {0}");
52 }
53 }
54
55 // Set the initial value of the watched variable:
56 if (m_target.GetProcessSP()) {
57 ExecutionContext exe_ctx;
58 m_target.GetProcessSP()->CalculateExecutionContext(exe_ctx);
59 CaptureWatchedValue(exe_ctx);
60 }
61 m_being_created = false;
62}
63
64Watchpoint::~Watchpoint() = default;
65
66// This function is used when "baton" doesn't need to be freed
68 bool is_synchronous) {
69 // The default "Baton" class will keep a copy of "baton" and won't free or
70 // delete it when it goes out of scope.
71 m_options.SetCallback(callback, std::make_shared<UntypedBaton>(baton),
72 is_synchronous);
73
74 SendWatchpointChangedEvent(eWatchpointEventTypeCommandChanged);
75}
76
77// This function is used when a baton needs to be freed and therefore is
78// contained in a "Baton" subclass.
80 const BatonSP &callback_baton_sp,
81 bool is_synchronous) {
82 m_options.SetCallback(callback, callback_baton_sp, is_synchronous);
83 SendWatchpointChangedEvent(eWatchpointEventTypeCommandChanged);
84}
85
87 if (!frame_sp)
88 return false;
89
90 ThreadSP thread_sp = frame_sp->GetThread();
91 if (!thread_sp)
92 return false;
93
94 uint32_t return_frame_index =
95 thread_sp->GetSelectedFrameIndex(DoNoSelectMostRelevantFrame) + 1;
96 if (return_frame_index >= LLDB_INVALID_FRAME_ID)
97 return false;
98
99 StackFrameSP return_frame_sp(
100 thread_sp->GetStackFrameAtIndex(return_frame_index));
101 if (!return_frame_sp)
102 return false;
103
104 ExecutionContext exe_ctx(return_frame_sp);
105 TargetSP target_sp = exe_ctx.GetTargetSP();
106 if (!target_sp)
107 return false;
108
109 Address return_address(return_frame_sp->GetFrameCodeAddress());
110 lldb::addr_t return_addr = return_address.GetLoadAddress(target_sp.get());
111 if (return_addr == LLDB_INVALID_ADDRESS)
112 return false;
113
114 BreakpointSP bp_sp = target_sp->CreateBreakpoint(
115 return_addr, /*internal=*/true, /*request_hardware=*/false);
116 if (!bp_sp || !bp_sp->HasResolvedLocations())
117 return false;
118
119 auto wvc_up = std::make_unique<WatchpointVariableContext>(GetID(), exe_ctx);
120 auto baton_sp = std::make_shared<WatchpointVariableBaton>(std::move(wvc_up));
121 bp_sp->SetCallback(VariableWatchpointDisabler, baton_sp);
122 bp_sp->SetOneShot(true);
123 bp_sp->SetBreakpointKind("variable watchpoint disabler");
124 return true;
125}
126
129 user_id_t break_id,
130 user_id_t break_loc_id) {
131 assert(baton && "null baton");
132 if (!baton || !context)
133 return false;
134
136
138 static_cast<WatchpointVariableContext *>(baton);
139
140 LLDB_LOGF(log, "called by breakpoint %" PRIu64 ".%" PRIu64, break_id,
141 break_loc_id);
142
144 return false;
145
146 TargetSP target_sp = context->exe_ctx_ref.GetTargetSP();
147 if (!target_sp)
148 return false;
149
150 ProcessSP process_sp = target_sp->GetProcessSP();
151 if (!process_sp)
152 return false;
153
154 WatchpointSP watch_sp =
155 target_sp->GetWatchpointList().FindByID(wvc->watch_id);
156 if (!watch_sp)
157 return false;
158
159 if (wvc->exe_ctx == context->exe_ctx_ref) {
160 LLDB_LOGF(log,
161 "callback for watchpoint %" PRId32
162 " matched internal breakpoint execution context",
163 watch_sp->GetID());
164 process_sp->DisableWatchpoint(watch_sp.get());
165 return false;
166 }
167 LLDB_LOGF(log,
168 "callback for watchpoint %" PRId32
169 " didn't match internal breakpoint execution context",
170 watch_sp->GetID());
171 return false;
172}
173
176 SendWatchpointChangedEvent(eWatchpointEventTypeCommandChanged);
177}
178
179void Watchpoint::SetDeclInfo(const std::string &str) { m_decl_str = str; }
180
182
183void Watchpoint::SetWatchSpec(const std::string &str) {
184 m_watch_spec_str = str;
185}
186
189 return m_is_hardware;
190}
191
193
195
197 ConstString g_watch_name("$__lldb__watch_value");
199 Address watch_address(GetLoadAddress());
200 if (!m_type.IsValid()) {
201 // Don't know how to report new & old values, since we couldn't make a
202 // scalar type for this watchpoint. This works around an assert in
203 // ValueObjectMemory::Create.
204 // FIXME: This should not happen, but if it does in some case we care about,
205 // we can go grab the value raw and print it as unsigned.
206 return false;
207 }
209 exe_ctx.GetBestExecutionContextScope(), g_watch_name.GetStringRef(),
210 watch_address, m_type);
211 m_new_value_sp = m_new_value_sp->CreateConstantValue(g_watch_name);
212 return (m_new_value_sp && m_new_value_sp->GetError().Success());
213}
214
217 return true;
218 if (!m_type.IsValid())
219 return true;
220
221 ConstString g_watch_name("$__lldb__watch_value");
222 Address watch_address(GetLoadAddress());
223 ValueObjectSP newest_valueobj_sp = ValueObjectMemory::Create(
224 exe_ctx.GetBestExecutionContextScope(), g_watch_name.GetStringRef(),
225 watch_address, m_type);
226 newest_valueobj_sp = newest_valueobj_sp->CreateConstantValue(g_watch_name);
228
229 DataExtractor new_data;
230 DataExtractor old_data;
231
232 newest_valueobj_sp->GetData(new_data, error);
233 if (error.Fail())
234 return true;
235 m_new_value_sp->GetData(old_data, error);
236 if (error.Fail())
237 return true;
238
239 if (new_data.GetByteSize() != old_data.GetByteSize() ||
240 new_data.GetByteSize() == 0)
241 return true;
242
243 if (memcmp(new_data.GetDataStart(), old_data.GetDataStart(),
244 old_data.GetByteSize()) == 0)
245 return false; // Value has not changed, user requested modify watchpoint
246
247 return true;
248}
249
250// RETURNS - true if we should stop at this breakpoint, false if we
251// should continue.
252
255
256 return IsEnabled();
257}
258
260 DumpWithLevel(s, level);
261}
262
263void Watchpoint::Dump(Stream *s) const {
265}
266
267// If prefix is nullptr, we display the watch id and ignore the prefix
268// altogether.
269void Watchpoint::DumpSnapshots(Stream *s, const char *prefix) const {
270 if (!prefix) {
271 s->Printf("\nWatchpoint %u hit:", GetID());
272 prefix = "";
273 }
274
275 if (m_old_value_sp) {
276 const char *old_value_cstr = m_old_value_sp->GetValueAsCString();
277 if (old_value_cstr && old_value_cstr[0])
278 s->Printf("\n%sold value: %s", prefix, old_value_cstr);
279 else {
280 const char *old_summary_cstr = m_old_value_sp->GetSummaryAsCString();
281 if (old_summary_cstr && old_summary_cstr[0])
282 s->Printf("\n%sold value: %s", prefix, old_summary_cstr);
283 }
284 }
285
286 if (m_new_value_sp) {
287 const char *new_value_cstr = m_new_value_sp->GetValueAsCString();
288 if (new_value_cstr && new_value_cstr[0])
289 s->Printf("\n%snew value: %s", prefix, new_value_cstr);
290 else {
291 const char *new_summary_cstr = m_new_value_sp->GetSummaryAsCString();
292 if (new_summary_cstr && new_summary_cstr[0])
293 s->Printf("\n%snew value: %s", prefix, new_summary_cstr);
294 }
295 }
296}
297
299 lldb::DescriptionLevel description_level) const {
300 if (s == nullptr)
301 return;
302
303 assert(description_level >= lldb::eDescriptionLevelBrief &&
304 description_level <= lldb::eDescriptionLevelVerbose);
305
306 s->Printf("Watchpoint %u: addr = 0x%8.8" PRIx64
307 " size = %u state = %s type = %s%s%s",
309 IsEnabled() ? "enabled" : "disabled", m_watch_read ? "r" : "",
310 m_watch_write ? "w" : "", m_watch_modify ? "m" : "");
311
312 if (description_level >= lldb::eDescriptionLevelFull) {
313 if (!m_decl_str.empty())
314 s->Printf("\n declare @ '%s'", m_decl_str.c_str());
315 if (!m_watch_spec_str.empty())
316 s->Printf("\n watchpoint spec = '%s'", m_watch_spec_str.c_str());
317
318 // Dump the snapshots we have taken.
319 DumpSnapshots(s, " ");
320
321 if (GetConditionText())
322 s->Printf("\n condition = '%s'", GetConditionText());
323 m_options.GetCallbackDescription(s, description_level);
324 }
325
326 if (description_level >= lldb::eDescriptionLevelVerbose) {
327 s->Printf("\n hw_index = %i hit_count = %-4u ignore_count = %-4u",
329 }
330}
331
332bool Watchpoint::IsEnabled() const { return m_enabled; }
333
334// Within StopInfo.cpp, we purposely turn on the ephemeral mode right before
335// temporarily disable the watchpoint in order to perform possible watchpoint
336// actions without triggering further watchpoint events. After the temporary
337// disabled watchpoint is enabled, we then turn off the ephemeral mode.
338
340
342 m_is_ephemeral = false;
343 // Leaving ephemeral mode, reset the m_disabled_count!
345}
346
348 return m_disabled_count > 1 && m_is_ephemeral;
349}
350
351void Watchpoint::SetEnabled(bool enabled, bool notify) {
352 if (!enabled) {
353 if (!m_is_ephemeral)
355 else
357
358 // Don't clear the snapshots for now.
359 // Within StopInfo.cpp, we purposely do disable/enable watchpoint while
360 // performing watchpoint actions.
361 }
362 bool changed = enabled != m_enabled;
363 m_enabled = enabled;
364 if (notify && !m_is_ephemeral && changed)
365 SendWatchpointChangedEvent(enabled ? eWatchpointEventTypeEnabled
366 : eWatchpointEventTypeDisabled);
367}
368
369void Watchpoint::SetWatchpointType(uint32_t type, bool notify) {
370 int old_watch_read = m_watch_read;
371 int old_watch_write = m_watch_write;
372 int old_watch_modify = m_watch_modify;
373 m_watch_read = (type & LLDB_WATCH_TYPE_READ) != 0;
374 m_watch_write = (type & LLDB_WATCH_TYPE_WRITE) != 0;
376 if (notify &&
377 (old_watch_read != m_watch_read || old_watch_write != m_watch_write ||
378 old_watch_modify != m_watch_modify))
379 SendWatchpointChangedEvent(eWatchpointEventTypeTypeChanged);
380}
381
382bool Watchpoint::WatchpointRead() const { return m_watch_read != 0; }
383
384bool Watchpoint::WatchpointWrite() const { return m_watch_write != 0; }
385
386bool Watchpoint::WatchpointModify() const { return m_watch_modify != 0; }
387
388uint32_t Watchpoint::GetIgnoreCount() const { return m_ignore_count; }
389
391 bool changed = m_ignore_count != n;
392 m_ignore_count = n;
393 if (changed)
394 SendWatchpointChangedEvent(eWatchpointEventTypeIgnoreChanged);
395}
396
398 return m_options.InvokeCallback(context, GetID());
399}
400
401void Watchpoint::SetCondition(const char *condition) {
402 if (condition == nullptr || condition[0] == '\0') {
403 if (m_condition_up)
404 m_condition_up.reset();
405 } else {
406 // Pass nullptr for expr_prefix (no translation-unit level definitions).
409 condition, llvm::StringRef(), lldb::eLanguageTypeUnknown,
411 error));
412 if (error.Fail()) {
413 // FIXME: Log something...
414 m_condition_up.reset();
415 }
416 }
417 SendWatchpointChangedEvent(eWatchpointEventTypeConditionChanged);
418}
419
420const char *Watchpoint::GetConditionText() const {
421 if (m_condition_up)
422 return m_condition_up->GetUserText();
423 else
424 return nullptr;
425}
426
428 lldb::WatchpointEventType eventKind) {
429 if (!m_being_created &&
430 GetTarget().EventTypeHasListeners(
432 WatchpointEventData *data =
433 new Watchpoint::WatchpointEventData(eventKind, shared_from_this());
435 }
436}
437
439 if (data == nullptr)
440 return;
441
442 if (!m_being_created &&
443 GetTarget().EventTypeHasListeners(Target::eBroadcastBitWatchpointChanged))
445 else
446 delete data;
447}
448
450 WatchpointEventType sub_type, const WatchpointSP &new_watchpoint_sp)
451 : m_watchpoint_event(sub_type), m_new_watchpoint_sp(new_watchpoint_sp) {}
452
454
456 return "Watchpoint::WatchpointEventData";
457}
458
461}
462
464 return m_new_watchpoint_sp;
465}
466
467WatchpointEventType
469 return m_watchpoint_event;
470}
471
473
476 if (event) {
477 const EventData *event_data = event->GetData();
478 if (event_data &&
480 return static_cast<const WatchpointEventData *>(event->GetData());
481 }
482 return nullptr;
483}
484
485WatchpointEventType
487 const EventSP &event_sp) {
488 const WatchpointEventData *data = GetEventDataFromEvent(event_sp.get());
489
490 if (data == nullptr)
491 return eWatchpointEventTypeInvalidType;
492 else
493 return data->GetWatchpointEventType();
494}
495
497 const EventSP &event_sp) {
498 WatchpointSP wp_sp;
499
500 const WatchpointEventData *data = GetEventDataFromEvent(event_sp.get());
501 if (data)
502 wp_sp = data->m_new_watchpoint_sp;
503
504 return wp_sp;
505}
static llvm::raw_ostream & error(Stream &strm)
#define lldbassert(x)
Definition: LLDBAssert.h:15
#define LLDB_LOGF(log,...)
Definition: Log.h:349
#define LLDB_LOG_ERROR(log, error,...)
Definition: Log.h:365
A section + offset based address class.
Definition: Address.h:59
lldb::addr_t GetLoadAddress(Target *target) const
Get the load address.
Definition: Address.cpp:311
void BroadcastEvent(lldb::EventSP &event_sp)
Broadcast an event which has no associated data.
Definition: Broadcaster.h:167
Generic representation of a type in a programming language.
Definition: CompilerType.h:36
A uniqued constant string class.
Definition: ConstString.h:40
llvm::StringRef GetStringRef() const
Get the string value as a llvm::StringRef.
Definition: ConstString.h:191
An data extractor class.
Definition: DataExtractor.h:48
const void * GetData(lldb::offset_t *offset_ptr, lldb::offset_t length) const
Extract length bytes from *offset_ptr.
uint64_t GetByteSize() const
Get the number of bytes contained in this object.
const uint8_t * GetDataStart() const
Get the data start pointer.
virtual llvm::StringRef GetFlavor() const =0
lldb::TargetSP GetTargetSP() const
Get accessor that creates a strong reference from the weak target reference contained in this object.
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
ExecutionContextScope * GetBestExecutionContextScope() const
const lldb::TargetSP & GetTargetSP() const
Get accessor to get the target shared pointer.
An error handling class.
Definition: Status.h:44
General Outline: When we hit a breakpoint we need to package up whatever information is needed to eva...
void Increment(uint32_t difference=1)
uint32_t GetHardwareIndex() const
Definition: StoppointSite.h:41
lldb::break_id_t GetID() const
Definition: StoppointSite.h:49
uint32_t GetHitCount() const
Definition: StoppointSite.h:33
void SetHardwareIndex(uint32_t index)
Definition: StoppointSite.h:43
StoppointHitCounter m_hit_counter
Number of times this breakpoint/watchpoint has been hit.
Definition: StoppointSite.h:71
virtual lldb::addr_t GetLoadAddress() const
Definition: StoppointSite.h:27
uint32_t m_byte_size
The size in bytes of stoppoint, e.g.
Definition: StoppointSite.h:68
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:107
UserExpression * GetUserExpressionForLanguage(llvm::StringRef expr, llvm::StringRef prefix, lldb::LanguageType language, Expression::ResultType desired_type, const EvaluateExpressionOptions &options, ValueObject *ctx_obj, Status &error)
Definition: Target.cpp:2462
const lldb::ProcessSP & GetProcessSP() const
Definition: Target.cpp:220
@ eBroadcastBitWatchpointChanged
Definition: Target.h:493
llvm::Expected< lldb::TypeSystemSP > GetScratchTypeSystemForLanguage(lldb::LanguageType language, bool create_on_demand=true)
Definition: Target.cpp:2370
static lldb::ValueObjectSP Create(ExecutionContextScope *exe_scope, llvm::StringRef name, const Address &address, lldb::TypeSP &type_sp)
void ClearCallback()
Remove the callback from this option set.
bool InvokeCallback(StoppointCallbackContext *context, lldb::user_id_t watch_id)
Use this function to invoke the callback for a specific stop.
void SetCallback(WatchpointHitCallback callback, const lldb::BatonSP &baton_sp, bool synchronous=false)
Adds a callback to the watchpoint option set.
void GetCallbackDescription(Stream *s, lldb::DescriptionLevel level) const
Get description for callback only.
static lldb::WatchpointSP GetWatchpointFromEvent(const lldb::EventSP &event_sp)
Definition: Watchpoint.cpp:496
lldb::WatchpointEventType GetWatchpointEventType() const
Definition: Watchpoint.cpp:468
llvm::StringRef GetFlavor() const override
Definition: Watchpoint.cpp:459
static lldb::WatchpointEventType GetWatchpointEventTypeFromEvent(const lldb::EventSP &event_sp)
Definition: Watchpoint.cpp:486
void Dump(Stream *s) const override
Definition: Watchpoint.cpp:472
static const WatchpointEventData * GetEventDataFromEvent(const Event *event_sp)
Definition: Watchpoint.cpp:475
WatchpointEventData(lldb::WatchpointEventType sub_type, const lldb::WatchpointSP &new_watchpoint_sp)
bool IsWatchVariable() const
Definition: Watchpoint.cpp:192
void SetCallback(WatchpointHitCallback callback, void *callback_baton, bool is_synchronous=false)
Set the callback action invoked when the watchpoint is hit.
Definition: Watchpoint.cpp:67
Watchpoint(Target &target, lldb::addr_t addr, uint32_t size, const CompilerType *type, bool hardware=true)
Definition: Watchpoint.cpp:27
bool CaptureWatchedValue(const ExecutionContext &exe_ctx)
Definition: Watchpoint.cpp:196
void DumpSnapshots(Stream *s, const char *prefix=nullptr) const
Definition: Watchpoint.cpp:269
uint32_t GetIgnoreCount() const
Definition: Watchpoint.cpp:388
bool InvokeCallback(StoppointCallbackContext *context)
Invoke the callback action when the watchpoint is hit.
Definition: Watchpoint.cpp:397
void SetIgnoreCount(uint32_t n)
Definition: Watchpoint.cpp:390
std::unique_ptr< UserExpression > m_condition_up
Definition: Watchpoint.h:232
void SetEnabled(bool enabled, bool notify=true)
Definition: Watchpoint.cpp:351
bool IsHardware() const override
Definition: Watchpoint.cpp:187
void Dump(Stream *s) const override
Definition: Watchpoint.cpp:263
bool WatchedValueReportable(const ExecutionContext &exe_ctx)
Definition: Watchpoint.cpp:215
void SendWatchpointChangedEvent(lldb::WatchpointEventType eventKind)
Definition: Watchpoint.cpp:427
std::string GetWatchSpec()
Definition: Watchpoint.cpp:181
lldb::ValueObjectSP m_new_value_sp
Definition: Watchpoint.h:223
static bool VariableWatchpointDisabler(void *baton, lldb_private::StoppointCallbackContext *context, lldb::user_id_t break_id, lldb::user_id_t break_loc_id)
Callback routine to disable the watchpoint set on a local variable when it goes out of scope.
Definition: Watchpoint.cpp:127
lldb::ValueObjectSP m_old_value_sp
Definition: Watchpoint.h:222
bool ShouldStop(StoppointCallbackContext *context) override
Definition: Watchpoint.cpp:253
void SetWatchSpec(const std::string &str)
Definition: Watchpoint.cpp:183
void SetWatchVariable(bool val)
Definition: Watchpoint.cpp:194
const char * GetConditionText() const
Return a pointer to the text of the condition expression.
Definition: Watchpoint.cpp:420
void GetDescription(Stream *s, lldb::DescriptionLevel level)
Definition: Watchpoint.cpp:259
WatchpointOptions m_options
Definition: Watchpoint.h:228
bool WatchpointRead() const
Definition: Watchpoint.cpp:382
std::string m_watch_spec_str
Definition: Watchpoint.h:221
bool SetupVariableWatchpointDisabler(lldb::StackFrameSP frame_sp) const
Definition: Watchpoint.cpp:86
bool WatchpointModify() const
Definition: Watchpoint.cpp:386
void SetCondition(const char *condition)
Set the watchpoint's condition.
Definition: Watchpoint.cpp:401
void SetWatchpointType(uint32_t type, bool notify=true)
Definition: Watchpoint.cpp:369
void SetDeclInfo(const std::string &str)
Definition: Watchpoint.cpp:179
bool WatchpointWrite() const
Definition: Watchpoint.cpp:384
void DumpWithLevel(Stream *s, lldb::DescriptionLevel description_level) const
Definition: Watchpoint.cpp:298
#define LLDB_WATCH_TYPE_WRITE
Definition: lldb-defines.h:46
#define LLDB_INVALID_WATCH_ID
Definition: lldb-defines.h:43
#define LLDB_INVALID_INDEX32
Definition: lldb-defines.h:77
#define LLDB_WATCH_TYPE_MODIFY
Definition: lldb-defines.h:47
#define LLDB_WATCH_TYPE_READ
Definition: lldb-defines.h:45
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:76
#define LLDB_INVALID_FRAME_ID
Definition: lldb-defines.h:85
@ DoNoSelectMostRelevantFrame
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:314
bool(* WatchpointHitCallback)(void *baton, StoppointCallbackContext *context, lldb::user_id_t watch_id)
Definition: SBAddress.h:15
std::shared_ptr< lldb_private::StackFrame > StackFrameSP
Definition: lldb-forward.h:399
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
@ eDescriptionLevelBrief
@ eDescriptionLevelFull
@ eDescriptionLevelVerbose
std::shared_ptr< lldb_private::Thread > ThreadSP
Definition: lldb-forward.h:425
std::shared_ptr< lldb_private::ValueObject > ValueObjectSP
Definition: lldb-forward.h:458
@ eLanguageTypeUnknown
Unknown or invalid language value.
@ eLanguageTypeC
Non-standardized C, such as K&R.
std::shared_ptr< lldb_private::Breakpoint > BreakpointSP
Definition: lldb-forward.h:303
std::shared_ptr< lldb_private::Process > ProcessSP
Definition: lldb-forward.h:368
std::shared_ptr< lldb_private::Baton > BatonSP
Definition: lldb-forward.h:301
@ eEncodingUint
unsigned integer
std::shared_ptr< lldb_private::Event > EventSP
Definition: lldb-forward.h:327
std::shared_ptr< lldb_private::Watchpoint > WatchpointSP
Definition: lldb-forward.h:463
uint64_t user_id_t
Definition: lldb-types.h:80
uint64_t addr_t
Definition: lldb-types.h:79
std::shared_ptr< lldb_private::Target > TargetSP
Definition: lldb-forward.h:423
Represents the context of a watchpoint variable.
Definition: Watchpoint.h:100
ExecutionContext exe_ctx
The execution context associated with the watchpoint.
Definition: Watchpoint.h:110
lldb::watch_id_t watch_id
The ID of the watchpoint.
Definition: Watchpoint.h:108