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
15#include "lldb/API/SBData.h"
16#include "lldb/API/SBError.h"
17#include "lldb/API/SBEvent.h"
21#include "lldb/API/SBStream.h"
37#include "lldb/Utility/Status.h"
39#include "lldb/lldb-private.h"
40#include <optional>
41
42namespace lldb_private {
43
45public:
47
48 virtual ~ScriptInterpreterLocker() = default;
49
50private:
54};
55
57public:
59
60 bool GetEnableIO() const { return m_enable_io; }
61
62 bool GetSetLLDBGlobals() const { return m_set_lldb_globals; }
63
64 // If this is true then any exceptions raised by the script will be
65 // cleared with PyErr_Clear(). If false then they will be left for
66 // the caller to clean up
67 bool GetMaskoutErrors() const { return m_maskout_errors; }
68
70 m_enable_io = enable;
71 return *this;
72 }
73
76 return *this;
77 }
78
80 m_maskout_errors = maskout;
81 return *this;
82 }
83
84private:
85 bool m_enable_io = true;
86 bool m_set_lldb_globals = true;
87 bool m_maskout_errors = true;
88};
89
91public:
92 LoadScriptOptions() = default;
93
94 bool GetInitSession() const { return m_init_session; }
95 bool GetSilent() const { return m_silent; }
96
99 return *this;
100 }
101
103 m_silent = b;
104 return *this;
105 }
106
107private:
108 bool m_init_session = false;
109 bool m_silent = false;
110};
111
113public:
114 /// Create an IO redirect. If IO is enabled, this will redirects the output
115 /// to the command return object if set or to the debugger otherwise. If IO
116 /// is disabled, it will redirect all IO to /dev/null.
117 static llvm::Expected<std::unique_ptr<ScriptInterpreterIORedirect>>
118 Create(bool enable_io, Debugger &debugger, CommandReturnObject *result);
119
121
124 return m_output_file_sp->GetUnlockedFileSP();
125 }
127 return m_error_file_sp->GetUnlockedFileSP();
128 }
129
130 /// Flush our output and error file handles.
131 void Flush();
132
133private:
134 ScriptInterpreterIORedirect(std::unique_ptr<File> input,
135 std::unique_ptr<File> output);
137
144};
145
147public:
165
166 ScriptInterpreter(Debugger &debugger, lldb::ScriptLanguage script_lang);
167
169
170 ~ScriptInterpreter() override = default;
171
172 virtual bool Interrupt() { return false; }
173
174 virtual bool ExecuteOneLine(
175 llvm::StringRef command, CommandReturnObject *result,
176 const ExecuteScriptOptions &options = ExecuteScriptOptions()) = 0;
177
178 virtual void ExecuteInterpreterLoop() = 0;
179
181 llvm::StringRef in_string, ScriptReturnType return_type, void *ret_value,
182 const ExecuteScriptOptions &options = ExecuteScriptOptions()) {
183 return true;
184 }
185
187 const char *in_string,
188 const ExecuteScriptOptions &options = ExecuteScriptOptions()) {
189 return Status::FromErrorString("not implemented");
190 }
191
192 virtual Status
194 return Status::FromErrorString("not implemented");
195 }
196
198 std::string &output,
199 bool has_extra_args,
200 bool is_callback) {
201 return Status::FromErrorString("not implemented");
202 }
203
205 std::string &output,
206 bool is_callback) {
207 return false;
208 }
209
210 virtual bool GenerateTypeScriptFunction(const char *oneliner,
211 std::string &output,
212 const void *name_token = nullptr) {
213 return false;
214 }
215
217 std::string &output,
218 const void *name_token = nullptr) {
219 return false;
220 }
221
223 std::string &output) {
224 return false;
225 }
226
227 virtual bool GenerateTypeSynthClass(StringList &input, std::string &output,
228 const void *name_token = nullptr) {
229 return false;
230 }
231
232 virtual bool GenerateTypeSynthClass(const char *oneliner, std::string &output,
233 const void *name_token = nullptr) {
234 return false;
235 }
236
238 CreateSyntheticScriptedProvider(const char *class_name,
239 lldb::ValueObjectSP valobj) {
241 }
242
244 CreateScriptCommandObject(const char *class_name) {
246 }
247
249 CreateFrameRecognizer(const char *class_name) {
251 }
252
258
259 virtual bool ShouldHide(const StructuredData::ObjectSP &implementor,
260 lldb::StackFrameSP frame_sp) {
261 return false;
262 }
263
268
271 const char *setting_name, lldb_private::Status &error) {
273 }
274
275 virtual Status GenerateFunction(const char *signature,
276 const StringList &input,
277 bool is_callback) {
278 return Status::FromErrorString("not implemented");
279 }
280
282 std::vector<std::reference_wrapper<BreakpointOptions>> &options,
283 CommandReturnObject &result);
284
285 virtual void
287 CommandReturnObject &result);
288
289 /// Set the specified text as the callback for the breakpoint.
291 std::vector<std::reference_wrapper<BreakpointOptions>> &bp_options_vec,
292 const char *callback_text);
293
295 const char *callback_text,
296 bool is_callback) {
297 return Status::FromErrorString("not implemented");
298 }
299
300 /// This one is for deserialization:
302 BreakpointOptions &bp_options,
303 std::unique_ptr<BreakpointOptions::CommandData> &data_up) {
304 return Status::FromErrorString("not implemented");
305 }
306
308 std::vector<std::reference_wrapper<BreakpointOptions>> &bp_options_vec,
309 const char *function_name, StructuredData::ObjectSP extra_args_sp);
310
311 /// Set a script function as the callback for the breakpoint.
312 virtual Status
314 const char *function_name,
315 StructuredData::ObjectSP extra_args_sp) {
316 return Status::FromErrorString("not implemented");
317 }
318
319 /// Set a one-liner as the callback for the watchpoint.
321 const char *user_input,
322 bool is_callback) {}
323
324 virtual bool GetScriptedSummary(const char *function_name,
325 lldb::ValueObjectSP valobj,
326 StructuredData::ObjectSP &callee_wrapper_sp,
327 const TypeSummaryOptions &options,
328 std::string &retval) {
329 return false;
330 }
331
332 // Calls the specified formatter matching Python function and returns its
333 // result (true if it's a match, false if we should keep looking for a
334 // matching formatter).
335 virtual bool FormatterCallbackFunction(const char *function_name,
336 lldb::TypeImplSP type_impl_sp) {
337 return true;
338 }
339
340 virtual void Clear() {
341 // Clean up any ref counts to SBObjects that might be in global variables
342 }
343
344 virtual size_t
346 uint32_t max) {
347 return 0;
348 }
349
350 virtual lldb::ValueObjectSP
351 GetChildAtIndex(const StructuredData::ObjectSP &implementor, uint32_t idx) {
352 return lldb::ValueObjectSP();
353 }
354
355 virtual llvm::Expected<int>
357 const char *child_name) {
358 return llvm::createStringError("Type has no child named '%s'", child_name);
359 }
360
361 virtual bool
363 return false;
364 }
365
367 const StructuredData::ObjectSP &implementor) {
368 return true;
369 }
370
371 virtual lldb::ValueObjectSP
373 return nullptr;
374 }
375
376 virtual ConstString
378 return ConstString();
379 }
380
381 virtual bool
382 RunScriptBasedCommand(const char *impl_function, llvm::StringRef args,
383 ScriptedCommandSynchronicity synchronicity,
385 Status &error,
386 const lldb_private::ExecutionContext &exe_ctx) {
387 return false;
388 }
389
391 StructuredData::GenericSP impl_obj_sp, llvm::StringRef args,
392 ScriptedCommandSynchronicity synchronicity,
394 const lldb_private::ExecutionContext &exe_ctx) {
395 return false;
396 }
397
399 StructuredData::GenericSP impl_obj_sp, Args& args,
400 ScriptedCommandSynchronicity synchronicity,
402 const lldb_private::ExecutionContext &exe_ctx) {
403 return false;
404 }
405
406 virtual std::optional<std::string>
408 Args &args) {
409 return std::nullopt;
410 }
411
414 StructuredData::GenericSP impl_obj_sp, std::vector<llvm::StringRef> &args,
415 size_t args_pos, size_t char_in_arg) {
416 return {};
417 }
418
421 StructuredData::GenericSP impl_obj_sp, llvm::StringRef &long_name,
422 size_t char_in_arg) {
423 return {};
424 }
425
426 virtual bool RunScriptFormatKeyword(const char *impl_function,
427 Process *process, std::string &output,
428 Status &error) {
429 error = Status::FromErrorString("unimplemented");
430 return false;
431 }
432
433 virtual bool RunScriptFormatKeyword(const char *impl_function, Thread *thread,
434 std::string &output, Status &error) {
435 error = Status::FromErrorString("unimplemented");
436 return false;
437 }
438
439 virtual bool RunScriptFormatKeyword(const char *impl_function, Target *target,
440 std::string &output, Status &error) {
441 error = Status::FromErrorString("unimplemented");
442 return false;
443 }
444
445 virtual bool RunScriptFormatKeyword(const char *impl_function,
446 StackFrame *frame, std::string &output,
447 Status &error) {
448 error = Status::FromErrorString("unimplemented");
449 return false;
450 }
451
452 virtual bool RunScriptFormatKeyword(const char *impl_function,
453 ValueObject *value, std::string &output,
454 Status &error) {
455 error = Status::FromErrorString("unimplemented");
456 return false;
457 }
458
459 virtual bool GetDocumentationForItem(const char *item, std::string &dest) {
460 dest.clear();
461 return false;
462 }
463
464 virtual bool
466 std::string &dest) {
467 dest.clear();
468 return false;
469 }
470
473 return {};
474 }
475
478 return {};
479 }
480
482 StructuredData::GenericSP cmd_obj_sp, ExecutionContext *exe_ctx,
483 llvm::StringRef long_option, llvm::StringRef value) {
484 return false;
485 }
486
487 virtual void
489
490 virtual uint32_t
492 return 0;
493 }
494
496 std::string &dest) {
497 dest.clear();
498 return false;
499 }
500
501 virtual bool CheckObjectExists(const char *name) { return false; }
502
503 virtual bool
504 LoadScriptingModule(const char *filename, const LoadScriptOptions &options,
506 StructuredData::ObjectSP *module_sp = nullptr,
507 FileSpec extra_search_dir = {},
508 lldb::TargetSP loaded_into_target_sp = {});
509
510 virtual bool IsReservedWord(const char *word) { return false; }
511
512 virtual std::unique_ptr<ScriptInterpreterLocker> AcquireInterpreterLock();
513
515
516 virtual llvm::Expected<unsigned>
517 GetMaxPositionalArgumentsForCallable(const llvm::StringRef &callable_name) {
518 return llvm::createStringError(
519 llvm::inconvertibleErrorCode(), "Unimplemented function");
520 }
521
522 static std::string LanguageToString(lldb::ScriptLanguage language);
523
524 static lldb::ScriptLanguage StringToLanguage(const llvm::StringRef &string);
525
527
531
535
539
542 return {};
543 }
544
548
552
556
559 return {};
560 }
561
566
568 GetDataExtractorFromSBData(const lldb::SBData &data) const;
569
571
572 Event *GetOpaqueTypeFromSBEvent(const lldb::SBEvent &event) const;
573
575
577
580
582 GetOpaqueTypeFromSBBreakpoint(const lldb::SBBreakpoint &breakpoint) const;
583
585 const lldb::SBBreakpointLocation &break_loc) const;
586
588 GetOpaqueTypeFromSBAttachInfo(const lldb::SBAttachInfo &attach_info) const;
589
591 GetOpaqueTypeFromSBLaunchInfo(const lldb::SBLaunchInfo &launch_info) const;
592
593 std::optional<MemoryRegionInfo> GetOpaqueTypeFromSBMemoryRegionInfo(
594 const lldb::SBMemoryRegionInfo &mem_region) const;
595
597 const lldb::SBExecutionContext &exe_ctx) const;
598
599protected:
602};
603
604} // namespace lldb_private
605
606#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:57
LoadScriptOptions & SetInitSession(bool b)
LoadScriptOptions & SetSilent(bool b)
std::recursive_mutex Mutex
Definition StreamFile.h:77
A plug-in interface definition class for debugging a process.
Definition Process.h:357
void Flush()
Flush our output and error file handles.
ScriptInterpreterIORedirect(std::unique_ptr< File > input, std::unique_ptr< File > output)
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())
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 lldb::ScriptedFrameInterfaceSP CreateScriptedFrameInterface()
virtual Status ExportFunctionDefinitionToInterpreter(StringList &function_def)
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)
SymbolContext GetOpaqueTypeFromSBSymbolContext(const lldb::SBSymbolContext &sym_ctx) const
virtual llvm::Expected< int > GetIndexOfChildWithName(const StructuredData::ObjectSP &implementor, const char *child_name)
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 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 lldb::ScriptedBreakpointInterfaceSP CreateScriptedBreakpointInterface()
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 LoadScriptingModule(const char *filename, const LoadScriptOptions &options, lldb_private::Status &error, StructuredData::ObjectSP *module_sp=nullptr, FileSpec extra_search_dir={}, lldb::TargetSP loaded_into_target_sp={})
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 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()
lldb::BreakpointLocationSP GetOpaqueTypeFromSBBreakpointLocation(const lldb::SBBreakpointLocation &break_loc) const
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 GetLanguage()
virtual uint32_t GetFlagsForCommandObject(StructuredData::GenericSP cmd_obj_sp)
virtual bool GetShortHelpForCommandObject(StructuredData::GenericSP cmd_obj_sp, std::string &dest)
lldb::StackFrameSP GetOpaqueTypeFromSBFrame(const lldb::SBFrame &frame) const
virtual bool ShouldHide(const StructuredData::ObjectSP &implementor, lldb::StackFrameSP frame_sp)
virtual bool IsReservedWord(const char *word)
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)
ScriptInterpreter(Debugger &debugger, lldb::ScriptLanguage script_lang)
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:118
static Status FromErrorString(const char *str)
Definition Status.h:141
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.
"lldb/Core/ThreadedCommunication.h" Variation of Communication that supports threaded reads.
"lldb/Breakpoint/WatchpointOptions.h" Class that manages the options on a watchpoint.
A class that represents a running process on the host machine.
std::unique_ptr< lldb_private::ScriptedPlatformInterface > ScriptedPlatformInterfaceUP
ScriptLanguage
Script interpreter types.
std::shared_ptr< lldb_private::ScriptedStopHookInterface > ScriptedStopHookInterfaceSP
std::shared_ptr< lldb_private::StackFrame > StackFrameSP
std::shared_ptr< lldb_private::BreakpointLocation > BreakpointLocationSP
std::shared_ptr< lldb_private::ScriptedThreadPlanInterface > ScriptedThreadPlanInterfaceSP
std::shared_ptr< lldb_private::ValueObject > ValueObjectSP
std::shared_ptr< lldb_private::ProcessAttachInfo > ProcessAttachInfoSP
std::shared_ptr< lldb_private::OperatingSystemInterface > OperatingSystemInterfaceSP
std::shared_ptr< lldb_private::Stream > StreamSP
std::shared_ptr< lldb_private::Breakpoint > BreakpointSP
std::shared_ptr< lldb_private::ScriptedBreakpointInterface > ScriptedBreakpointInterfaceSP
std::shared_ptr< lldb_private::ScriptedThreadInterface > ScriptedThreadInterfaceSP
std::shared_ptr< lldb_private::ValueObjectList > ValueObjectListSP
std::shared_ptr< lldb_private::LockableStreamFile > LockableStreamFileSP
std::shared_ptr< lldb_private::TypeImpl > TypeImplSP
std::shared_ptr< lldb_private::Target > TargetSP
std::shared_ptr< lldb_private::File > FileSP
std::shared_ptr< lldb_private::DataExtractor > DataExtractorSP
std::unique_ptr< lldb_private::ScriptedProcessInterface > ScriptedProcessInterfaceUP
std::shared_ptr< lldb_private::ProcessLaunchInfo > ProcessLaunchInfoSP
std::shared_ptr< lldb_private::ScriptedFrameInterface > ScriptedFrameInterfaceSP
std::shared_ptr< lldb_private::ExecutionContextRef > ExecutionContextRefSP