LLDB mainline
ScriptInterpreter.h
Go to the documentation of this file.
1//===-- ScriptInterpreter.h -------------------------------------*- C++ -*-===//
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
9#ifndef LLDB_INTERPRETER_SCRIPTINTERPRETER_H
10#define LLDB_INTERPRETER_SCRIPTINTERPRETER_H
11
14#include "lldb/API/SBData.h"
15#include "lldb/API/SBError.h"
16#include "lldb/API/SBEvent.h"
20#include "lldb/API/SBStream.h"
33#include "lldb/Utility/Status.h"
35#include "lldb/lldb-private.h"
36#include <optional>
37
38namespace lldb_private {
39
41public:
43
44 virtual ~ScriptInterpreterLocker() = default;
45
46private:
50};
51
53public:
55
56 bool GetEnableIO() const { return m_enable_io; }
57
58 bool GetSetLLDBGlobals() const { return m_set_lldb_globals; }
59
60 // If this is true then any exceptions raised by the script will be
61 // cleared with PyErr_Clear(). If false then they will be left for
62 // the caller to clean up
63 bool GetMaskoutErrors() const { return m_maskout_errors; }
64
66 m_enable_io = enable;
67 return *this;
68 }
69
72 return *this;
73 }
74
76 m_maskout_errors = maskout;
77 return *this;
78 }
79
80private:
81 bool m_enable_io = true;
82 bool m_set_lldb_globals = true;
83 bool m_maskout_errors = true;
84};
85
87public:
88 LoadScriptOptions() = default;
89
90 bool GetInitSession() const { return m_init_session; }
91 bool GetSilent() const { return m_silent; }
92
95 return *this;
96 }
97
99 m_silent = b;
100 return *this;
101 }
102
103private:
104 bool m_init_session = false;
105 bool m_silent = false;
106};
107
109public:
110 /// Create an IO redirect. If IO is enabled, this will redirects the output
111 /// to the command return object if set or to the debugger otherwise. If IO
112 /// is disabled, it will redirect all IO to /dev/null.
113 static llvm::Expected<std::unique_ptr<ScriptInterpreterIORedirect>>
114 Create(bool enable_io, Debugger &debugger, CommandReturnObject *result);
115
117
119 lldb::FileSP GetOutputFile() const { return m_output_file_sp->GetFileSP(); }
120 lldb::FileSP GetErrorFile() const { return m_error_file_sp->GetFileSP(); }
121
122 /// Flush our output and error file handles.
123 void Flush();
124
125private:
126 ScriptInterpreterIORedirect(std::unique_ptr<File> input,
127 std::unique_ptr<File> output);
129
135};
136
138public:
155 };
156
157 ScriptInterpreter(Debugger &debugger, lldb::ScriptLanguage script_lang);
158
160
161 ~ScriptInterpreter() override = default;
162
163 virtual bool Interrupt() { return false; }
164
165 virtual bool ExecuteOneLine(
166 llvm::StringRef command, CommandReturnObject *result,
167 const ExecuteScriptOptions &options = ExecuteScriptOptions()) = 0;
168
169 virtual void ExecuteInterpreterLoop() = 0;
170
172 llvm::StringRef in_string, ScriptReturnType return_type, void *ret_value,
173 const ExecuteScriptOptions &options = ExecuteScriptOptions()) {
174 return true;
175 }
176
178 const char *in_string,
179 const ExecuteScriptOptions &options = ExecuteScriptOptions()) {
180 return Status::FromErrorString("not implemented");
181 }
182
183 virtual Status
185 return Status::FromErrorString("not implemented");
186 }
187
189 std::string &output,
190 bool has_extra_args,
191 bool is_callback) {
192 return Status::FromErrorString("not implemented");
193 }
194
196 std::string &output,
197 bool is_callback) {
198 return false;
199 }
200
201 virtual bool GenerateTypeScriptFunction(const char *oneliner,
202 std::string &output,
203 const void *name_token = nullptr) {
204 return false;
205 }
206
208 std::string &output,
209 const void *name_token = nullptr) {
210 return false;
211 }
212
214 std::string &output) {
215 return false;
216 }
217
218 virtual bool GenerateTypeSynthClass(StringList &input, std::string &output,
219 const void *name_token = nullptr) {
220 return false;
221 }
222
223 virtual bool GenerateTypeSynthClass(const char *oneliner, std::string &output,
224 const void *name_token = nullptr) {
225 return false;
226 }
227
229 CreateSyntheticScriptedProvider(const char *class_name,
230 lldb::ValueObjectSP valobj) {
232 }
233
235 CreateScriptCommandObject(const char *class_name) {
237 }
238
240 CreateFrameRecognizer(const char *class_name) {
242 }
243
245 const StructuredData::ObjectSP &implementor,
246 lldb::StackFrameSP frame_sp) {
248 }
249
250 virtual bool ShouldHide(const StructuredData::ObjectSP &implementor,
251 lldb::StackFrameSP frame_sp) {
252 return false;
253 }
254
256 CreateScriptedBreakpointResolver(const char *class_name,
257 const StructuredDataImpl &args_data,
258 lldb::BreakpointSP &bkpt_sp) {
260 }
261
262 virtual bool
264 SymbolContext *sym_ctx)
265 {
266 return false;
267 }
268
269 virtual lldb::SearchDepth
271 {
273 }
274
278 }
279
282 const char *setting_name, lldb_private::Status &error) {
284 }
285
286 virtual Status GenerateFunction(const char *signature,
287 const StringList &input,
288 bool is_callback) {
289 return Status::FromErrorString("not implemented");
290 }
291
293 std::vector<std::reference_wrapper<BreakpointOptions>> &options,
294 CommandReturnObject &result);
295
296 virtual void
298 CommandReturnObject &result);
299
300 /// Set the specified text as the callback for the breakpoint.
302 std::vector<std::reference_wrapper<BreakpointOptions>> &bp_options_vec,
303 const char *callback_text);
304
306 const char *callback_text,
307 bool is_callback) {
308 return Status::FromErrorString("not implemented");
309 }
310
311 /// This one is for deserialization:
313 BreakpointOptions &bp_options,
314 std::unique_ptr<BreakpointOptions::CommandData> &data_up) {
315 return Status::FromErrorString("not implemented");
316 }
317
319 std::vector<std::reference_wrapper<BreakpointOptions>> &bp_options_vec,
320 const char *function_name, StructuredData::ObjectSP extra_args_sp);
321
322 /// Set a script function as the callback for the breakpoint.
323 virtual Status
325 const char *function_name,
326 StructuredData::ObjectSP extra_args_sp) {
327 return Status::FromErrorString("not implemented");
328 }
329
330 /// Set a one-liner as the callback for the watchpoint.
332 const char *user_input,
333 bool is_callback) {}
334
335 virtual bool GetScriptedSummary(const char *function_name,
336 lldb::ValueObjectSP valobj,
337 StructuredData::ObjectSP &callee_wrapper_sp,
338 const TypeSummaryOptions &options,
339 std::string &retval) {
340 return false;
341 }
342
343 // Calls the specified formatter matching Python function and returns its
344 // result (true if it's a match, false if we should keep looking for a
345 // matching formatter).
346 virtual bool FormatterCallbackFunction(const char *function_name,
347 lldb::TypeImplSP type_impl_sp) {
348 return true;
349 }
350
351 virtual void Clear() {
352 // Clean up any ref counts to SBObjects that might be in global variables
353 }
354
355 virtual size_t
357 uint32_t max) {
358 return 0;
359 }
360
361 virtual lldb::ValueObjectSP
362 GetChildAtIndex(const StructuredData::ObjectSP &implementor, uint32_t idx) {
363 return lldb::ValueObjectSP();
364 }
365
366 virtual int
368 const char *child_name) {
369 return UINT32_MAX;
370 }
371
372 virtual bool
374 return false;
375 }
376
378 const StructuredData::ObjectSP &implementor) {
379 return true;
380 }
381
382 virtual lldb::ValueObjectSP
384 return nullptr;
385 }
386
387 virtual ConstString
389 return ConstString();
390 }
391
392 virtual bool
393 RunScriptBasedCommand(const char *impl_function, llvm::StringRef args,
394 ScriptedCommandSynchronicity synchronicity,
396 Status &error,
397 const lldb_private::ExecutionContext &exe_ctx) {
398 return false;
399 }
400
402 StructuredData::GenericSP impl_obj_sp, llvm::StringRef args,
403 ScriptedCommandSynchronicity synchronicity,
405 const lldb_private::ExecutionContext &exe_ctx) {
406 return false;
407 }
408
410 StructuredData::GenericSP impl_obj_sp, Args& args,
411 ScriptedCommandSynchronicity synchronicity,
413 const lldb_private::ExecutionContext &exe_ctx) {
414 return false;
415 }
416
417 virtual std::optional<std::string>
419 Args &args) {
420 return std::nullopt;
421 }
422
425 StructuredData::GenericSP impl_obj_sp, std::vector<llvm::StringRef> &args,
426 size_t args_pos, size_t char_in_arg) {
427 return {};
428 }
429
432 StructuredData::GenericSP impl_obj_sp, llvm::StringRef &long_name,
433 size_t char_in_arg) {
434 return {};
435 }
436
437 virtual bool RunScriptFormatKeyword(const char *impl_function,
438 Process *process, std::string &output,
439 Status &error) {
440 error = Status::FromErrorString("unimplemented");
441 return false;
442 }
443
444 virtual bool RunScriptFormatKeyword(const char *impl_function, Thread *thread,
445 std::string &output, Status &error) {
446 error = Status::FromErrorString("unimplemented");
447 return false;
448 }
449
450 virtual bool RunScriptFormatKeyword(const char *impl_function, Target *target,
451 std::string &output, Status &error) {
452 error = Status::FromErrorString("unimplemented");
453 return false;
454 }
455
456 virtual bool RunScriptFormatKeyword(const char *impl_function,
457 StackFrame *frame, std::string &output,
458 Status &error) {
459 error = Status::FromErrorString("unimplemented");
460 return false;
461 }
462
463 virtual bool RunScriptFormatKeyword(const char *impl_function,
464 ValueObject *value, std::string &output,
465 Status &error) {
466 error = Status::FromErrorString("unimplemented");
467 return false;
468 }
469
470 virtual bool GetDocumentationForItem(const char *item, std::string &dest) {
471 dest.clear();
472 return false;
473 }
474
475 virtual bool
477 std::string &dest) {
478 dest.clear();
479 return false;
480 }
481
484 return {};
485 }
486
489 return {};
490 }
491
493 StructuredData::GenericSP cmd_obj_sp, ExecutionContext *exe_ctx,
494 llvm::StringRef long_option, llvm::StringRef value) {
495 return false;
496 }
497
499 StructuredData::GenericSP cmd_obj_sp) {
500 return;
501 }
502
503 virtual uint32_t
505 return 0;
506 }
507
509 std::string &dest) {
510 dest.clear();
511 return false;
512 }
513
514 virtual bool CheckObjectExists(const char *name) { return false; }
515
516 virtual bool
517 LoadScriptingModule(const char *filename, const LoadScriptOptions &options,
519 StructuredData::ObjectSP *module_sp = nullptr,
520 FileSpec extra_search_dir = {});
521
522 virtual bool IsReservedWord(const char *word) { return false; }
523
524 virtual std::unique_ptr<ScriptInterpreterLocker> AcquireInterpreterLock();
525
527
528 virtual llvm::Expected<unsigned>
529 GetMaxPositionalArgumentsForCallable(const llvm::StringRef &callable_name) {
530 return llvm::createStringError(
531 llvm::inconvertibleErrorCode(), "Unimplemented function");
532 }
533
534 static std::string LanguageToString(lldb::ScriptLanguage language);
535
536 static lldb::ScriptLanguage StringToLanguage(const llvm::StringRef &string);
537
539
541 return {};
542 }
543
545 return {};
546 }
547
550 return {};
551 }
552
554 return {};
555 }
556
558 return {};
559 }
560
562 return {};
563 }
564
567 return {};
568 }
569
571 GetDataExtractorFromSBData(const lldb::SBData &data) const;
572
574
575 Event *GetOpaqueTypeFromSBEvent(const lldb::SBEvent &event) const;
576
578
580 GetOpaqueTypeFromSBBreakpoint(const lldb::SBBreakpoint &breakpoint) const;
581
583 GetOpaqueTypeFromSBAttachInfo(const lldb::SBAttachInfo &attach_info) const;
584
586 GetOpaqueTypeFromSBLaunchInfo(const lldb::SBLaunchInfo &launch_info) const;
587
588 std::optional<MemoryRegionInfo> GetOpaqueTypeFromSBMemoryRegionInfo(
589 const lldb::SBMemoryRegionInfo &mem_region) const;
590
592 const lldb::SBExecutionContext &exe_ctx) const;
593
594protected:
597};
598
599} // namespace lldb_private
600
601#endif // LLDB_INTERPRETER_SCRIPTINTERPRETER_H
static llvm::raw_ostream & error(Stream &strm)
A command line argument class.
Definition: Args.h:33
"lldb/Breakpoint/BreakpointOptions.h" Class that manages the options on a breakpoint or breakpoint lo...
A uniqued constant string class.
Definition: ConstString.h:40
A class to manage flag bits.
Definition: Debugger.h:80
ExecuteScriptOptions & SetMaskoutErrors(bool maskout)
ExecuteScriptOptions & SetSetLLDBGlobals(bool set)
ExecuteScriptOptions & SetEnableIO(bool enable)
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
A file utility class.
Definition: FileSpec.h:56
LoadScriptOptions & SetInitSession(bool b)
LoadScriptOptions & SetSilent(bool b)
A plug-in interface definition class for debugging a process.
Definition: Process.h:343
void Flush()
Flush our output and error file handles.
static llvm::Expected< std::unique_ptr< ScriptInterpreterIORedirect > > Create(bool enable_io, Debugger &debugger, CommandReturnObject *result)
Create an IO redirect.
const ScriptInterpreterLocker & operator=(const ScriptInterpreterLocker &)=delete
ScriptInterpreterLocker(const ScriptInterpreterLocker &)=delete
virtual ~ScriptInterpreterLocker()=default
virtual bool SetOptionValueForCommandObject(StructuredData::GenericSP cmd_obj_sp, ExecutionContext *exe_ctx, llvm::StringRef long_option, llvm::StringRef value)
static lldb::ScriptLanguage StringToLanguage(const llvm::StringRef &string)
virtual void CollectDataForBreakpointCommandCallback(std::vector< std::reference_wrapper< BreakpointOptions > > &options, CommandReturnObject &result)
virtual lldb::ValueObjectListSP GetRecognizedArguments(const StructuredData::ObjectSP &implementor, lldb::StackFrameSP frame_sp)
const char * GetScriptInterpreterPtyName()
lldb::ProcessAttachInfoSP GetOpaqueTypeFromSBAttachInfo(const lldb::SBAttachInfo &attach_info) const
virtual Status ExecuteMultipleLines(const char *in_string, const ExecuteScriptOptions &options=ExecuteScriptOptions())
virtual bool LoadScriptingModule(const char *filename, const LoadScriptOptions &options, lldb_private::Status &error, StructuredData::ObjectSP *module_sp=nullptr, FileSpec extra_search_dir={})
lldb::StreamSP GetOpaqueTypeFromSBStream(const lldb::SBStream &stream) const
virtual StructuredData::GenericSP CreateScriptCommandObject(const char *class_name)
virtual size_t CalculateNumChildren(const StructuredData::ObjectSP &implementor, uint32_t max)
virtual bool GenerateTypeScriptFunction(const char *oneliner, std::string &output, const void *name_token=nullptr)
virtual bool RunScriptFormatKeyword(const char *impl_function, Target *target, std::string &output, Status &error)
virtual bool GenerateTypeScriptFunction(StringList &input, std::string &output, const void *name_token=nullptr)
virtual lldb::ScriptedProcessInterfaceUP CreateScriptedProcessInterface()
virtual Status ExportFunctionDefinitionToInterpreter(StringList &function_def)
virtual int GetIndexOfChildWithName(const StructuredData::ObjectSP &implementor, const char *child_name)
lldb::ExecutionContextRefSP GetOpaqueTypeFromSBExecutionContext(const lldb::SBExecutionContext &exe_ctx) const
~ScriptInterpreter() override=default
virtual lldb::OperatingSystemInterfaceSP CreateOperatingSystemInterface()
virtual StructuredData::ObjectSP CreateSyntheticScriptedProvider(const char *class_name, lldb::ValueObjectSP valobj)
virtual Status SetBreakpointCommandCallbackFunction(BreakpointOptions &bp_options, const char *function_name, StructuredData::ObjectSP extra_args_sp)
Set a script function as the callback for the breakpoint.
virtual llvm::Expected< unsigned > GetMaxPositionalArgumentsForCallable(const llvm::StringRef &callable_name)
virtual bool ExecuteOneLineWithReturn(llvm::StringRef in_string, ScriptReturnType return_type, void *ret_value, const ExecuteScriptOptions &options=ExecuteScriptOptions())
virtual bool ScriptedBreakpointResolverSearchCallback(StructuredData::GenericSP implementor_sp, SymbolContext *sym_ctx)
virtual bool GenerateTypeSynthClass(StringList &input, std::string &output, const void *name_token=nullptr)
virtual bool RunScriptBasedCommand(const char *impl_function, llvm::StringRef args, ScriptedCommandSynchronicity synchronicity, lldb_private::CommandReturnObject &cmd_retobj, Status &error, const lldb_private::ExecutionContext &exe_ctx)
virtual void ExecuteInterpreterLoop()=0
virtual StructuredData::GenericSP CreateFrameRecognizer(const char *class_name)
virtual bool GenerateScriptAliasFunction(StringList &input, std::string &output)
virtual bool MightHaveChildrenSynthProviderInstance(const StructuredData::ObjectSP &implementor)
virtual bool GenerateWatchpointCommandCallbackData(StringList &input, std::string &output, bool is_callback)
virtual StructuredData::DictionarySP GetDynamicSettings(StructuredData::ObjectSP plugin_module_sp, Target *target, const char *setting_name, lldb_private::Status &error)
virtual StructuredData::DictionarySP HandleOptionArgumentCompletionForScriptedCommand(StructuredData::GenericSP impl_obj_sp, llvm::StringRef &long_name, size_t char_in_arg)
virtual Status GenerateFunction(const char *signature, const StringList &input, bool is_callback)
virtual lldb::ValueObjectSP GetChildAtIndex(const StructuredData::ObjectSP &implementor, uint32_t idx)
Event * GetOpaqueTypeFromSBEvent(const lldb::SBEvent &event) const
virtual std::optional< std::string > GetRepeatCommandForScriptedCommand(StructuredData::GenericSP impl_obj_sp, Args &args)
virtual void SetWatchpointCommandCallback(WatchpointOptions *wp_options, const char *user_input, bool is_callback)
Set a one-liner as the callback for the watchpoint.
Status SetBreakpointCommandCallback(std::vector< std::reference_wrapper< BreakpointOptions > > &bp_options_vec, const char *callback_text)
Set the specified text as the callback for the breakpoint.
lldb::ProcessLaunchInfoSP GetOpaqueTypeFromSBLaunchInfo(const lldb::SBLaunchInfo &launch_info) const
virtual lldb::ValueObjectSP GetSyntheticValue(const StructuredData::ObjectSP &implementor)
virtual bool ExecuteOneLine(llvm::StringRef command, CommandReturnObject *result, const ExecuteScriptOptions &options=ExecuteScriptOptions())=0
virtual bool RunScriptFormatKeyword(const char *impl_function, StackFrame *frame, std::string &output, Status &error)
virtual Status GenerateBreakpointCommandCallbackData(StringList &input, std::string &output, bool has_extra_args, bool is_callback)
static std::string LanguageToString(lldb::ScriptLanguage language)
virtual lldb::SearchDepth ScriptedBreakpointResolverSearchDepth(StructuredData::GenericSP implementor_sp)
virtual bool RunScriptFormatKeyword(const char *impl_function, ValueObject *value, std::string &output, Status &error)
Status GetStatusFromSBError(const lldb::SBError &error) const
std::optional< MemoryRegionInfo > GetOpaqueTypeFromSBMemoryRegionInfo(const lldb::SBMemoryRegionInfo &mem_region) const
virtual std::unique_ptr< ScriptInterpreterLocker > AcquireInterpreterLock()
virtual bool GetDocumentationForItem(const char *item, std::string &dest)
virtual StructuredData::DictionarySP GetInterpreterInfo()
virtual bool UpdateSynthProviderInstance(const StructuredData::ObjectSP &implementor)
virtual lldb::ScriptedStopHookInterfaceSP CreateScriptedStopHookInterface()
virtual StructuredData::ObjectSP LoadPluginModule(const FileSpec &file_spec, lldb_private::Status &error)
virtual bool RunScriptBasedParsedCommand(StructuredData::GenericSP impl_obj_sp, Args &args, ScriptedCommandSynchronicity synchronicity, lldb_private::CommandReturnObject &cmd_retobj, Status &error, const lldb_private::ExecutionContext &exe_ctx)
Status SetBreakpointCommandCallbackFunction(std::vector< std::reference_wrapper< BreakpointOptions > > &bp_options_vec, const char *function_name, StructuredData::ObjectSP extra_args_sp)
virtual bool GenerateTypeSynthClass(const char *oneliner, std::string &output, const void *name_token=nullptr)
virtual StructuredData::ObjectSP CreateStructuredDataFromScriptObject(ScriptObject obj)
virtual StructuredData::ObjectSP GetOptionsForCommandObject(StructuredData::GenericSP cmd_obj_sp)
virtual StructuredData::ObjectSP GetArgumentsForCommandObject(StructuredData::GenericSP cmd_obj_sp)
virtual void OptionParsingStartedForCommandObject(StructuredData::GenericSP cmd_obj_sp)
virtual bool GetScriptedSummary(const char *function_name, lldb::ValueObjectSP valobj, StructuredData::ObjectSP &callee_wrapper_sp, const TypeSummaryOptions &options, std::string &retval)
virtual Status SetBreakpointCommandCallback(BreakpointOptions &bp_options, std::unique_ptr< BreakpointOptions::CommandData > &data_up)
This one is for deserialization:
lldb::BreakpointSP GetOpaqueTypeFromSBBreakpoint(const lldb::SBBreakpoint &breakpoint) const
virtual bool GetLongHelpForCommandObject(StructuredData::GenericSP cmd_obj_sp, std::string &dest)
virtual lldb::ScriptedThreadPlanInterfaceSP CreateScriptedThreadPlanInterface()
virtual bool RunScriptFormatKeyword(const char *impl_function, Thread *thread, std::string &output, Status &error)
virtual bool CheckObjectExists(const char *name)
virtual bool RunScriptBasedCommand(StructuredData::GenericSP impl_obj_sp, llvm::StringRef args, ScriptedCommandSynchronicity synchronicity, lldb_private::CommandReturnObject &cmd_retobj, Status &error, const lldb_private::ExecutionContext &exe_ctx)
virtual bool FormatterCallbackFunction(const char *function_name, lldb::TypeImplSP type_impl_sp)
virtual ConstString GetSyntheticTypeName(const StructuredData::ObjectSP &implementor)
lldb::ScriptLanguage m_script_lang
lldb::ScriptLanguage GetLanguage()
virtual uint32_t GetFlagsForCommandObject(StructuredData::GenericSP cmd_obj_sp)
virtual bool GetShortHelpForCommandObject(StructuredData::GenericSP cmd_obj_sp, std::string &dest)
virtual bool ShouldHide(const StructuredData::ObjectSP &implementor, lldb::StackFrameSP frame_sp)
virtual bool IsReservedWord(const char *word)
virtual StructuredData::GenericSP CreateScriptedBreakpointResolver(const char *class_name, const StructuredDataImpl &args_data, lldb::BreakpointSP &bkpt_sp)
virtual StructuredData::DictionarySP HandleArgumentCompletionForScriptedCommand(StructuredData::GenericSP impl_obj_sp, std::vector< llvm::StringRef > &args, size_t args_pos, size_t char_in_arg)
lldb::DataExtractorSP GetDataExtractorFromSBData(const lldb::SBData &data) const
virtual lldb::ScriptedPlatformInterfaceUP GetScriptedPlatformInterface()
virtual bool RunScriptFormatKeyword(const char *impl_function, Process *process, std::string &output, Status &error)
virtual lldb::ScriptedThreadInterfaceSP CreateScriptedThreadInterface()
virtual Status SetBreakpointCommandCallback(BreakpointOptions &bp_options, const char *callback_text, bool is_callback)
virtual void CollectDataForWatchpointCommandCallback(WatchpointOptions *wp_options, CommandReturnObject &result)
This base class provides an interface to stack frames.
Definition: StackFrame.h:44
An error handling class.
Definition: Status.h:115
static Status FromErrorString(const char *str)
Definition: Status.h:138
std::shared_ptr< Generic > GenericSP
std::shared_ptr< Dictionary > DictionarySP
std::shared_ptr< Object > ObjectSP
Defines a symbol context baton that can be handed other debug core functions.
Definition: SymbolContext.h:34
"lldb/Core/ThreadedCommunication.h" Variation of Communication that supports threaded reads.
"lldb/Breakpoint/WatchpointOptions.h" Class that manages the options on a watchpoint.
#define UINT32_MAX
Definition: lldb-defines.h:19
A class that represents a running process on the host machine.
std::unique_ptr< lldb_private::ScriptedPlatformInterface > ScriptedPlatformInterfaceUP
Definition: lldb-forward.h:409
ScriptLanguage
Script interpreter types.
std::shared_ptr< lldb_private::ScriptedStopHookInterface > ScriptedStopHookInterfaceSP
Definition: lldb-forward.h:413
std::shared_ptr< lldb_private::StackFrame > StackFrameSP
Definition: lldb-forward.h:424
std::shared_ptr< lldb_private::ScriptedThreadPlanInterface > ScriptedThreadPlanInterfaceSP
Definition: lldb-forward.h:417
std::shared_ptr< lldb_private::ValueObject > ValueObjectSP
Definition: lldb-forward.h:484
std::shared_ptr< lldb_private::ProcessAttachInfo > ProcessAttachInfoSP
Definition: lldb-forward.h:390
std::shared_ptr< lldb_private::OperatingSystemInterface > OperatingSystemInterfaceSP
Definition: lldb-forward.h:383
std::shared_ptr< lldb_private::Stream > StreamSP
Definition: lldb-forward.h:432
std::shared_ptr< lldb_private::Breakpoint > BreakpointSP
Definition: lldb-forward.h:321
std::shared_ptr< lldb_private::ScriptedThreadInterface > ScriptedThreadInterfaceSP
Definition: lldb-forward.h:415
std::shared_ptr< lldb_private::ValueObjectList > ValueObjectListSP
Definition: lldb-forward.h:488
std::shared_ptr< lldb_private::StreamFile > StreamFileSP
Definition: lldb-forward.h:433
@ eSearchDepthModule
std::shared_ptr< lldb_private::TypeImpl > TypeImplSP
Definition: lldb-forward.h:464
std::shared_ptr< lldb_private::File > FileSP
Definition: lldb-forward.h:353
std::shared_ptr< lldb_private::DataExtractor > DataExtractorSP
Definition: lldb-forward.h:338
std::unique_ptr< lldb_private::ScriptedProcessInterface > ScriptedProcessInterfaceUP
Definition: lldb-forward.h:411
std::shared_ptr< lldb_private::ProcessLaunchInfo > ProcessLaunchInfoSP
Definition: lldb-forward.h:391
std::shared_ptr< lldb_private::ExecutionContextRef > ExecutionContextRefSP
Definition: lldb-forward.h:350