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"
28#include "lldb/Utility/Status.h"
30#include "lldb/lldb-private.h"
31#include <optional>
32
33namespace lldb_private {
34
36public:
38
39 virtual ~ScriptInterpreterLocker() = default;
40
41private:
45};
46
48public:
50
51 bool GetEnableIO() const { return m_enable_io; }
52
53 bool GetSetLLDBGlobals() const { return m_set_lldb_globals; }
54
55 // If this is true then any exceptions raised by the script will be
56 // cleared with PyErr_Clear(). If false then they will be left for
57 // the caller to clean up
58 bool GetMaskoutErrors() const { return m_maskout_errors; }
59
61 m_enable_io = enable;
62 return *this;
63 }
64
67 return *this;
68 }
69
71 m_maskout_errors = maskout;
72 return *this;
73 }
74
75private:
76 bool m_enable_io = true;
77 bool m_set_lldb_globals = true;
78 bool m_maskout_errors = true;
79};
80
82public:
83 LoadScriptOptions() = default;
84
85 bool GetInitSession() const { return m_init_session; }
86 bool GetSilent() const { return m_silent; }
87
90 return *this;
91 }
92
94 m_silent = b;
95 return *this;
96 }
97
98private:
99 bool m_init_session = false;
100 bool m_silent = false;
101};
102
104public:
105 /// Create an IO redirect. If IO is enabled, this will redirects the output
106 /// to the command return object if set or to the debugger otherwise. If IO
107 /// is disabled, it will redirect all IO to /dev/null.
108 static llvm::Expected<std::unique_ptr<ScriptInterpreterIORedirect>>
109 Create(bool enable_io, Debugger &debugger, CommandReturnObject *result);
110
112
114 lldb::FileSP GetOutputFile() const { return m_output_file_sp->GetFileSP(); }
115 lldb::FileSP GetErrorFile() const { return m_error_file_sp->GetFileSP(); }
116
117 /// Flush our output and error file handles.
118 void Flush();
119
120private:
121 ScriptInterpreterIORedirect(std::unique_ptr<File> input,
122 std::unique_ptr<File> output);
124
130};
131
133public:
150 };
151
153 Debugger &debugger, lldb::ScriptLanguage script_lang,
154 lldb::ScriptedPlatformInterfaceUP scripted_platform_interface_up =
155 std::make_unique<ScriptedPlatformInterface>());
156
158
159 ~ScriptInterpreter() override = default;
160
161 virtual bool Interrupt() { return false; }
162
163 virtual bool ExecuteOneLine(
164 llvm::StringRef command, CommandReturnObject *result,
165 const ExecuteScriptOptions &options = ExecuteScriptOptions()) = 0;
166
167 virtual void ExecuteInterpreterLoop() = 0;
168
170 llvm::StringRef in_string, ScriptReturnType return_type, void *ret_value,
171 const ExecuteScriptOptions &options = ExecuteScriptOptions()) {
172 return true;
173 }
174
176 const char *in_string,
177 const ExecuteScriptOptions &options = ExecuteScriptOptions()) {
179 error.SetErrorString("not implemented");
180 return error;
181 }
182
183 virtual Status
186 error.SetErrorString("not implemented");
187 return error;
188 }
189
191 std::string &output,
192 bool has_extra_args,
193 bool is_callback) {
195 error.SetErrorString("not implemented");
196 return error;
197 }
198
200 std::string &output,
201 bool is_callback) {
202 return false;
203 }
204
205 virtual bool GenerateTypeScriptFunction(const char *oneliner,
206 std::string &output,
207 const void *name_token = nullptr) {
208 return false;
209 }
210
212 std::string &output,
213 const void *name_token = nullptr) {
214 return false;
215 }
216
218 std::string &output) {
219 return false;
220 }
221
222 virtual bool GenerateTypeSynthClass(StringList &input, std::string &output,
223 const void *name_token = nullptr) {
224 return false;
225 }
226
227 virtual bool GenerateTypeSynthClass(const char *oneliner, std::string &output,
228 const void *name_token = nullptr) {
229 return false;
230 }
231
233 CreateSyntheticScriptedProvider(const char *class_name,
234 lldb::ValueObjectSP valobj) {
236 }
237
239 CreateScriptCommandObject(const char *class_name) {
241 }
242
244 CreateFrameRecognizer(const char *class_name) {
246 }
247
249 const StructuredData::ObjectSP &implementor,
250 lldb::StackFrameSP frame_sp) {
252 }
253
255 OSPlugin_CreatePluginObject(const char *class_name,
256 lldb::ProcessSP process_sp) {
258 }
259
263 }
264
268 }
269
272 lldb::tid_t thread_id) {
274 }
275
278 lldb::tid_t tid, lldb::addr_t context) {
280 }
281
283 CreateScriptedThreadPlan(const char *class_name,
284 const StructuredDataImpl &args_data,
285 std::string &error_str,
286 lldb::ThreadPlanSP thread_plan_sp) {
288 }
289
290 virtual bool
292 Event *event, bool &script_error) {
293 script_error = true;
294 return true;
295 }
296
297 virtual bool
299 Event *event, bool &script_error) {
300 script_error = true;
301 return true;
302 }
303
304 virtual bool
306 bool &script_error) {
307 script_error = true;
308 return true;
309 }
310
311 virtual lldb::StateType
313 bool &script_error) {
314 script_error = true;
316 }
317
318 virtual bool
320 lldb_private::Stream *stream,
321 bool &script_error) {
322 script_error = true;
323 return false;
324 }
325
327 CreateScriptedBreakpointResolver(const char *class_name,
328 const StructuredDataImpl &args_data,
329 lldb::BreakpointSP &bkpt_sp) {
331 }
332
333 virtual bool
335 SymbolContext *sym_ctx)
336 {
337 return false;
338 }
339
340 virtual lldb::SearchDepth
342 {
344 }
345
347 CreateScriptedStopHook(lldb::TargetSP target_sp, const char *class_name,
348 const StructuredDataImpl &args_data, Status &error) {
349 error.SetErrorString("Creating scripted stop-hooks with the current "
350 "script interpreter is not supported.");
352 }
353
354 // This dispatches to the handle_stop method of the stop-hook class. It
355 // returns a "should_stop" bool.
356 virtual bool
358 ExecutionContext &exc_ctx,
359 lldb::StreamSP stream_sp) {
360 return true;
361 }
362
366 }
367
370 const char *setting_name, lldb_private::Status &error) {
372 }
373
374 virtual Status GenerateFunction(const char *signature,
375 const StringList &input,
376 bool is_callback) {
378 error.SetErrorString("unimplemented");
379 return error;
380 }
381
383 std::vector<std::reference_wrapper<BreakpointOptions>> &options,
384 CommandReturnObject &result);
385
386 virtual void
388 CommandReturnObject &result);
389
390 /// Set the specified text as the callback for the breakpoint.
392 std::vector<std::reference_wrapper<BreakpointOptions>> &bp_options_vec,
393 const char *callback_text);
394
396 const char *callback_text,
397 bool is_callback) {
399 error.SetErrorString("unimplemented");
400 return error;
401 }
402
403 /// This one is for deserialization:
405 BreakpointOptions &bp_options,
406 std::unique_ptr<BreakpointOptions::CommandData> &data_up) {
408 error.SetErrorString("unimplemented");
409 return error;
410 }
411
413 std::vector<std::reference_wrapper<BreakpointOptions>> &bp_options_vec,
414 const char *function_name, StructuredData::ObjectSP extra_args_sp);
415
416 /// Set a script function as the callback for the breakpoint.
417 virtual Status
419 const char *function_name,
420 StructuredData::ObjectSP extra_args_sp) {
422 error.SetErrorString("unimplemented");
423 return error;
424 }
425
426 /// Set a one-liner as the callback for the watchpoint.
428 const char *user_input,
429 bool is_callback) {}
430
431 virtual bool GetScriptedSummary(const char *function_name,
432 lldb::ValueObjectSP valobj,
433 StructuredData::ObjectSP &callee_wrapper_sp,
434 const TypeSummaryOptions &options,
435 std::string &retval) {
436 return false;
437 }
438
439 // Calls the specified formatter matching Python function and returns its
440 // result (true if it's a match, false if we should keep looking for a
441 // matching formatter).
442 virtual bool FormatterCallbackFunction(const char *function_name,
443 lldb::TypeImplSP type_impl_sp) {
444 return true;
445 }
446
447 virtual void Clear() {
448 // Clean up any ref counts to SBObjects that might be in global variables
449 }
450
451 virtual size_t
453 uint32_t max) {
454 return 0;
455 }
456
457 virtual lldb::ValueObjectSP
458 GetChildAtIndex(const StructuredData::ObjectSP &implementor, uint32_t idx) {
459 return lldb::ValueObjectSP();
460 }
461
462 virtual int
464 const char *child_name) {
465 return UINT32_MAX;
466 }
467
468 virtual bool
470 return false;
471 }
472
474 const StructuredData::ObjectSP &implementor) {
475 return true;
476 }
477
478 virtual lldb::ValueObjectSP
480 return nullptr;
481 }
482
483 virtual ConstString
485 return ConstString();
486 }
487
488 virtual bool
489 RunScriptBasedCommand(const char *impl_function, llvm::StringRef args,
490 ScriptedCommandSynchronicity synchronicity,
492 Status &error,
493 const lldb_private::ExecutionContext &exe_ctx) {
494 return false;
495 }
496
498 StructuredData::GenericSP impl_obj_sp, llvm::StringRef args,
499 ScriptedCommandSynchronicity synchronicity,
501 const lldb_private::ExecutionContext &exe_ctx) {
502 return false;
503 }
504
505 virtual bool RunScriptFormatKeyword(const char *impl_function,
506 Process *process, std::string &output,
507 Status &error) {
508 error.SetErrorString("unimplemented");
509 return false;
510 }
511
512 virtual bool RunScriptFormatKeyword(const char *impl_function, Thread *thread,
513 std::string &output, Status &error) {
514 error.SetErrorString("unimplemented");
515 return false;
516 }
517
518 virtual bool RunScriptFormatKeyword(const char *impl_function, Target *target,
519 std::string &output, Status &error) {
520 error.SetErrorString("unimplemented");
521 return false;
522 }
523
524 virtual bool RunScriptFormatKeyword(const char *impl_function,
525 StackFrame *frame, std::string &output,
526 Status &error) {
527 error.SetErrorString("unimplemented");
528 return false;
529 }
530
531 virtual bool RunScriptFormatKeyword(const char *impl_function,
532 ValueObject *value, std::string &output,
533 Status &error) {
534 error.SetErrorString("unimplemented");
535 return false;
536 }
537
538 virtual bool GetDocumentationForItem(const char *item, std::string &dest) {
539 dest.clear();
540 return false;
541 }
542
543 virtual bool
545 std::string &dest) {
546 dest.clear();
547 return false;
548 }
549
550 virtual uint32_t
552 return 0;
553 }
554
556 std::string &dest) {
557 dest.clear();
558 return false;
559 }
560
561 virtual bool CheckObjectExists(const char *name) { return false; }
562
563 virtual bool
564 LoadScriptingModule(const char *filename, const LoadScriptOptions &options,
566 StructuredData::ObjectSP *module_sp = nullptr,
567 FileSpec extra_search_dir = {});
568
569 virtual bool IsReservedWord(const char *word) { return false; }
570
571 virtual std::unique_ptr<ScriptInterpreterLocker> AcquireInterpreterLock();
572
574
575 virtual llvm::Expected<unsigned>
576 GetMaxPositionalArgumentsForCallable(const llvm::StringRef &callable_name) {
577 return llvm::createStringError(
578 llvm::inconvertibleErrorCode(), "Unimplemented function");
579 }
580
581 static std::string LanguageToString(lldb::ScriptLanguage language);
582
583 static lldb::ScriptLanguage StringToLanguage(const llvm::StringRef &string);
584
586
588 return std::make_unique<ScriptedProcessInterface>();
589 }
590
593 }
594
597 return {};
598 }
599
601 GetDataExtractorFromSBData(const lldb::SBData &data) const;
602
604
606 GetOpaqueTypeFromSBBreakpoint(const lldb::SBBreakpoint &breakpoint) const;
607
609 GetOpaqueTypeFromSBAttachInfo(const lldb::SBAttachInfo &attach_info) const;
610
612 GetOpaqueTypeFromSBLaunchInfo(const lldb::SBLaunchInfo &launch_info) const;
613
614 std::optional<MemoryRegionInfo> GetOpaqueTypeFromSBMemoryRegionInfo(
615 const lldb::SBMemoryRegionInfo &mem_region) const;
616
617protected:
621};
622
623} // namespace lldb_private
624
625#endif // LLDB_INTERPRETER_SCRIPTINTERPRETER_H
static llvm::raw_ostream & error(Stream &strm)
"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:79
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:336
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
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={})
virtual StructuredData::GenericSP CreateScriptCommandObject(const char *class_name)
virtual bool ScriptedThreadPlanGetStopDescription(StructuredData::ObjectSP implementor_sp, lldb_private::Stream *stream, bool &script_error)
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)
~ScriptInterpreter() override=default
virtual StructuredData::ObjectSP CreateSyntheticScriptedProvider(const char *class_name, lldb::ValueObjectSP valobj)
virtual StructuredData::DictionarySP OSPlugin_CreateThread(StructuredData::ObjectSP os_plugin_object_sp, lldb::tid_t tid, lldb::addr_t context)
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 StructuredData::ObjectSP CreateScriptedThreadPlan(const char *class_name, const StructuredDataImpl &args_data, std::string &error_str, lldb::ThreadPlanSP thread_plan_sp)
virtual bool MightHaveChildrenSynthProviderInstance(const StructuredData::ObjectSP &implementor)
virtual StructuredData::StringSP OSPlugin_RegisterContextData(StructuredData::ObjectSP os_plugin_object_sp, lldb::tid_t thread_id)
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 bool ScriptedStopHookHandleStop(StructuredData::GenericSP implementor_sp, ExecutionContext &exc_ctx, lldb::StreamSP stream_sp)
virtual Status GenerateFunction(const char *signature, const StringList &input, bool is_callback)
virtual lldb::ValueObjectSP GetChildAtIndex(const StructuredData::ObjectSP &implementor, uint32_t idx)
virtual void SetWatchpointCommandCallback(WatchpointOptions *wp_options, const char *user_input, bool is_callback)
Set a one-liner as the callback for the watchpoint.
ScriptedPlatformInterface & GetScriptedPlatformInterface()
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
lldb::ScriptedPlatformInterfaceUP m_scripted_platform_interface_up
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 ScriptedThreadPlanExplainsStop(StructuredData::ObjectSP implementor_sp, Event *event, bool &script_error)
virtual bool UpdateSynthProviderInstance(const StructuredData::ObjectSP &implementor)
virtual StructuredData::ObjectSP LoadPluginModule(const FileSpec &file_spec, lldb_private::Status &error)
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 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:
virtual lldb::StateType ScriptedThreadPlanGetRunState(StructuredData::ObjectSP implementor_sp, bool &script_error)
virtual StructuredData::GenericSP OSPlugin_CreatePluginObject(const char *class_name, lldb::ProcessSP process_sp)
lldb::BreakpointSP GetOpaqueTypeFromSBBreakpoint(const lldb::SBBreakpoint &breakpoint) const
virtual bool GetLongHelpForCommandObject(StructuredData::GenericSP cmd_obj_sp, std::string &dest)
virtual bool ScriptedThreadPlanShouldStop(StructuredData::ObjectSP implementor_sp, Event *event, bool &script_error)
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 StructuredData::GenericSP CreateScriptedStopHook(lldb::TargetSP target_sp, const char *class_name, const StructuredDataImpl &args_data, Status &error)
virtual bool ScriptedThreadPlanIsStale(StructuredData::ObjectSP implementor_sp, bool &script_error)
virtual bool IsReservedWord(const char *word)
virtual StructuredData::GenericSP CreateScriptedBreakpointResolver(const char *class_name, const StructuredDataImpl &args_data, lldb::BreakpointSP &bkpt_sp)
lldb::DataExtractorSP GetDataExtractorFromSBData(const lldb::SBData &data) const
virtual bool RunScriptFormatKeyword(const char *impl_function, Process *process, std::string &output, Status &error)
virtual Status SetBreakpointCommandCallback(BreakpointOptions &bp_options, const char *callback_text, bool is_callback)
virtual void CollectDataForWatchpointCommandCallback(WatchpointOptions *wp_options, CommandReturnObject &result)
virtual StructuredData::DictionarySP OSPlugin_RegisterInfo(StructuredData::ObjectSP os_plugin_object_sp)
virtual StructuredData::ArraySP OSPlugin_ThreadsInfo(StructuredData::ObjectSP os_plugin_object_sp)
This base class provides an interface to stack frames.
Definition: StackFrame.h:41
An error handling class.
Definition: Status.h:44
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
std::shared_ptr< Generic > GenericSP
std::shared_ptr< Dictionary > DictionarySP
std::shared_ptr< Object > ObjectSP
std::shared_ptr< String > StringSP
std::shared_ptr< Array > ArraySP
Defines a symbol context baton that can be handed other debug core functions.
Definition: SymbolContext.h:33
"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.
Definition: SBAttachInfo.h:14
std::unique_ptr< lldb_private::ScriptedPlatformInterface > ScriptedPlatformInterfaceUP
Definition: lldb-forward.h:388
ScriptLanguage
Script interpreter types.
std::shared_ptr< lldb_private::ThreadPlan > ThreadPlanSP
Definition: lldb-forward.h:428
std::shared_ptr< lldb_private::StackFrame > StackFrameSP
Definition: lldb-forward.h:399
std::shared_ptr< lldb_private::ValueObject > ValueObjectSP
Definition: lldb-forward.h:458
std::shared_ptr< lldb_private::ProcessAttachInfo > ProcessAttachInfoSP
Definition: lldb-forward.h:369
StateType
Process and Thread States.
@ eStateStepping
Process or thread is in the process of stepping and can not be examined.
std::shared_ptr< lldb_private::Stream > StreamSP
Definition: lldb-forward.h:407
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::ValueObjectList > ValueObjectListSP
Definition: lldb-forward.h:462
std::shared_ptr< lldb_private::StreamFile > StreamFileSP
Definition: lldb-forward.h:408
@ eSearchDepthModule
uint64_t addr_t
Definition: lldb-types.h:79
std::shared_ptr< lldb_private::TypeImpl > TypeImplSP
Definition: lldb-forward.h:439
std::shared_ptr< lldb_private::Target > TargetSP
Definition: lldb-forward.h:423
std::shared_ptr< lldb_private::File > FileSP
Definition: lldb-forward.h:335
std::shared_ptr< lldb_private::DataExtractor > DataExtractorSP
Definition: lldb-forward.h:320
std::unique_ptr< lldb_private::ScriptedProcessInterface > ScriptedProcessInterfaceUP
Definition: lldb-forward.h:390
std::shared_ptr< lldb_private::ProcessLaunchInfo > ProcessLaunchInfoSP
Definition: lldb-forward.h:370
uint64_t tid_t
Definition: lldb-types.h:82