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
13#include "lldb/API/SBData.h"
14#include "lldb/API/SBError.h"
26#include "lldb/Utility/Status.h"
28#include "lldb/lldb-private.h"
29#include <optional>
30
31namespace lldb_private {
32
34public:
36
37 virtual ~ScriptInterpreterLocker() = default;
38
39private:
43};
44
46public:
48
49 bool GetEnableIO() const { return m_enable_io; }
50
51 bool GetSetLLDBGlobals() const { return m_set_lldb_globals; }
52
53 // If this is true then any exceptions raised by the script will be
54 // cleared with PyErr_Clear(). If false then they will be left for
55 // the caller to clean up
56 bool GetMaskoutErrors() const { return m_maskout_errors; }
57
59 m_enable_io = enable;
60 return *this;
61 }
62
65 return *this;
66 }
67
69 m_maskout_errors = maskout;
70 return *this;
71 }
72
73private:
74 bool m_enable_io = true;
75 bool m_set_lldb_globals = true;
76 bool m_maskout_errors = true;
77};
78
80public:
81 LoadScriptOptions() = default;
82
83 bool GetInitSession() const { return m_init_session; }
84 bool GetSilent() const { return m_silent; }
85
88 return *this;
89 }
90
92 m_silent = b;
93 return *this;
94 }
95
96private:
97 bool m_init_session = false;
98 bool m_silent = false;
99};
100
102public:
103 /// Create an IO redirect. If IO is enabled, this will redirects the output
104 /// to the command return object if set or to the debugger otherwise. If IO
105 /// is disabled, it will redirect all IO to /dev/null.
106 static llvm::Expected<std::unique_ptr<ScriptInterpreterIORedirect>>
107 Create(bool enable_io, Debugger &debugger, CommandReturnObject *result);
108
110
111 lldb::FileSP GetInputFile() const { return m_input_file_sp; }
112 lldb::FileSP GetOutputFile() const { return m_output_file_sp->GetFileSP(); }
113 lldb::FileSP GetErrorFile() const { return m_error_file_sp->GetFileSP(); }
114
115 /// Flush our output and error file handles.
116 void Flush();
117
118private:
119 ScriptInterpreterIORedirect(std::unique_ptr<File> input,
120 std::unique_ptr<File> output);
122
123 lldb::FileSP m_input_file_sp;
124 lldb::StreamFileSP m_output_file_sp;
125 lldb::StreamFileSP m_error_file_sp;
128};
129
131public:
148 };
149
151 Debugger &debugger, lldb::ScriptLanguage script_lang,
152 lldb::ScriptedPlatformInterfaceUP scripted_platform_interface_up =
153 std::make_unique<ScriptedPlatformInterface>());
154
156
157 ~ScriptInterpreter() override = default;
158
159 virtual bool Interrupt() { return false; }
160
161 virtual bool ExecuteOneLine(
162 llvm::StringRef command, CommandReturnObject *result,
163 const ExecuteScriptOptions &options = ExecuteScriptOptions()) = 0;
164
165 virtual void ExecuteInterpreterLoop() = 0;
166
168 llvm::StringRef in_string, ScriptReturnType return_type, void *ret_value,
169 const ExecuteScriptOptions &options = ExecuteScriptOptions()) {
170 return true;
171 }
172
174 const char *in_string,
175 const ExecuteScriptOptions &options = ExecuteScriptOptions()) {
177 error.SetErrorString("not implemented");
178 return error;
179 }
180
181 virtual Status
184 error.SetErrorString("not implemented");
185 return error;
186 }
187
189 std::string &output,
190 bool has_extra_args,
191 bool is_callback) {
193 error.SetErrorString("not implemented");
194 return error;
195 }
196
198 std::string &output,
199 bool is_callback) {
200 return false;
201 }
202
203 virtual bool GenerateTypeScriptFunction(const char *oneliner,
204 std::string &output,
205 const void *name_token = nullptr) {
206 return false;
207 }
208
210 std::string &output,
211 const void *name_token = nullptr) {
212 return false;
213 }
214
216 std::string &output) {
217 return false;
218 }
219
220 virtual bool GenerateTypeSynthClass(StringList &input, std::string &output,
221 const void *name_token = nullptr) {
222 return false;
223 }
224
225 virtual bool GenerateTypeSynthClass(const char *oneliner, std::string &output,
226 const void *name_token = nullptr) {
227 return false;
228 }
229
231 CreateSyntheticScriptedProvider(const char *class_name,
232 lldb::ValueObjectSP valobj) {
234 }
235
237 CreateScriptCommandObject(const char *class_name) {
239 }
240
242 CreateFrameRecognizer(const char *class_name) {
244 }
245
246 virtual lldb::ValueObjectListSP GetRecognizedArguments(
247 const StructuredData::ObjectSP &implementor,
248 lldb::StackFrameSP frame_sp) {
249 return lldb::ValueObjectListSP();
250 }
251
253 OSPlugin_CreatePluginObject(const char *class_name,
254 lldb::ProcessSP process_sp) {
256 }
257
261 }
262
266 }
267
270 lldb::tid_t thread_id) {
272 }
273
276 lldb::tid_t tid, lldb::addr_t context) {
278 }
279
281 CreateScriptedThreadPlan(const char *class_name,
282 const StructuredDataImpl &args_data,
283 std::string &error_str,
284 lldb::ThreadPlanSP thread_plan_sp) {
286 }
287
288 virtual bool
290 Event *event, bool &script_error) {
291 script_error = true;
292 return true;
293 }
294
295 virtual bool
297 Event *event, bool &script_error) {
298 script_error = true;
299 return true;
300 }
301
302 virtual bool
304 bool &script_error) {
305 script_error = true;
306 return true;
307 }
308
309 virtual lldb::StateType
311 bool &script_error) {
312 script_error = true;
314 }
315
317 CreateScriptedBreakpointResolver(const char *class_name,
318 const StructuredDataImpl &args_data,
319 lldb::BreakpointSP &bkpt_sp) {
321 }
322
323 virtual bool
325 SymbolContext *sym_ctx)
326 {
327 return false;
328 }
329
330 virtual lldb::SearchDepth
332 {
334 }
335
337 CreateScriptedStopHook(lldb::TargetSP target_sp, const char *class_name,
338 const StructuredDataImpl &args_data, Status &error) {
339 error.SetErrorString("Creating scripted stop-hooks with the current "
340 "script interpreter is not supported.");
342 }
343
344 // This dispatches to the handle_stop method of the stop-hook class. It
345 // returns a "should_stop" bool.
346 virtual bool
348 ExecutionContext &exc_ctx,
349 lldb::StreamSP stream_sp) {
350 return true;
351 }
352
356 }
357
360 const char *setting_name, lldb_private::Status &error) {
362 }
363
364 virtual Status GenerateFunction(const char *signature,
365 const StringList &input,
366 bool is_callback) {
368 error.SetErrorString("unimplemented");
369 return error;
370 }
371
373 std::vector<std::reference_wrapper<BreakpointOptions>> &options,
374 CommandReturnObject &result);
375
376 virtual void
378 CommandReturnObject &result);
379
380 /// Set the specified text as the callback for the breakpoint.
382 std::vector<std::reference_wrapper<BreakpointOptions>> &bp_options_vec,
383 const char *callback_text);
384
386 const char *callback_text,
387 bool is_callback) {
389 error.SetErrorString("unimplemented");
390 return error;
391 }
392
393 /// This one is for deserialization:
395 BreakpointOptions &bp_options,
396 std::unique_ptr<BreakpointOptions::CommandData> &data_up) {
398 error.SetErrorString("unimplemented");
399 return error;
400 }
401
403 std::vector<std::reference_wrapper<BreakpointOptions>> &bp_options_vec,
404 const char *function_name, StructuredData::ObjectSP extra_args_sp);
405
406 /// Set a script function as the callback for the breakpoint.
407 virtual Status
409 const char *function_name,
410 StructuredData::ObjectSP extra_args_sp) {
412 error.SetErrorString("unimplemented");
413 return error;
414 }
415
416 /// Set a one-liner as the callback for the watchpoint.
418 const char *user_input,
419 bool is_callback) {}
420
421 virtual bool GetScriptedSummary(const char *function_name,
422 lldb::ValueObjectSP valobj,
423 StructuredData::ObjectSP &callee_wrapper_sp,
424 const TypeSummaryOptions &options,
425 std::string &retval) {
426 return false;
427 }
428
429 // Calls the specified formatter matching Python function and returns its
430 // result (true if it's a match, false if we should keep looking for a
431 // matching formatter).
432 virtual bool FormatterCallbackFunction(const char *function_name,
433 lldb::TypeImplSP type_impl_sp) {
434 return true;
435 }
436
437 virtual void Clear() {
438 // Clean up any ref counts to SBObjects that might be in global variables
439 }
440
441 virtual size_t
443 uint32_t max) {
444 return 0;
445 }
446
447 virtual lldb::ValueObjectSP
449 return lldb::ValueObjectSP();
450 }
451
452 virtual int
454 const char *child_name) {
455 return UINT32_MAX;
456 }
457
458 virtual bool
460 return false;
461 }
462
464 const StructuredData::ObjectSP &implementor) {
465 return true;
466 }
467
468 virtual lldb::ValueObjectSP
470 return nullptr;
471 }
472
473 virtual ConstString
475 return ConstString();
476 }
477
478 virtual bool
479 RunScriptBasedCommand(const char *impl_function, llvm::StringRef args,
480 ScriptedCommandSynchronicity synchronicity,
482 Status &error,
483 const lldb_private::ExecutionContext &exe_ctx) {
484 return false;
485 }
486
488 StructuredData::GenericSP impl_obj_sp, llvm::StringRef args,
489 ScriptedCommandSynchronicity synchronicity,
491 const lldb_private::ExecutionContext &exe_ctx) {
492 return false;
493 }
494
495 virtual bool RunScriptFormatKeyword(const char *impl_function,
496 Process *process, std::string &output,
497 Status &error) {
498 error.SetErrorString("unimplemented");
499 return false;
500 }
501
502 virtual bool RunScriptFormatKeyword(const char *impl_function, Thread *thread,
503 std::string &output, Status &error) {
504 error.SetErrorString("unimplemented");
505 return false;
506 }
507
508 virtual bool RunScriptFormatKeyword(const char *impl_function, Target *target,
509 std::string &output, Status &error) {
510 error.SetErrorString("unimplemented");
511 return false;
512 }
513
514 virtual bool RunScriptFormatKeyword(const char *impl_function,
515 StackFrame *frame, std::string &output,
516 Status &error) {
517 error.SetErrorString("unimplemented");
518 return false;
519 }
520
521 virtual bool RunScriptFormatKeyword(const char *impl_function,
522 ValueObject *value, std::string &output,
523 Status &error) {
524 error.SetErrorString("unimplemented");
525 return false;
526 }
527
528 virtual bool GetDocumentationForItem(const char *item, std::string &dest) {
529 dest.clear();
530 return false;
531 }
532
533 virtual bool
535 std::string &dest) {
536 dest.clear();
537 return false;
538 }
539
540 virtual uint32_t
542 return 0;
543 }
544
546 std::string &dest) {
547 dest.clear();
548 return false;
549 }
550
551 virtual bool CheckObjectExists(const char *name) { return false; }
552
553 virtual bool
554 LoadScriptingModule(const char *filename, const LoadScriptOptions &options,
556 StructuredData::ObjectSP *module_sp = nullptr,
557 FileSpec extra_search_dir = {});
558
559 virtual bool IsReservedWord(const char *word) { return false; }
560
561 virtual std::unique_ptr<ScriptInterpreterLocker> AcquireInterpreterLock();
562
564
565 virtual llvm::Expected<unsigned>
566 GetMaxPositionalArgumentsForCallable(const llvm::StringRef &callable_name) {
567 return llvm::createStringError(
568 llvm::inconvertibleErrorCode(), "Unimplemented function");
569 }
570
571 static std::string LanguageToString(lldb::ScriptLanguage language);
572
573 static lldb::ScriptLanguage StringToLanguage(const llvm::StringRef &string);
574
576
577 virtual lldb::ScriptedProcessInterfaceUP CreateScriptedProcessInterface() {
578 return std::make_unique<ScriptedProcessInterface>();
579 }
580
583 }
584
585 lldb::DataExtractorSP
586 GetDataExtractorFromSBData(const lldb::SBData &data) const;
587
589
590 lldb::ProcessAttachInfoSP
591 GetOpaqueTypeFromSBAttachInfo(const lldb::SBAttachInfo &attach_info) const;
592
593 lldb::ProcessLaunchInfoSP
594 GetOpaqueTypeFromSBLaunchInfo(const lldb::SBLaunchInfo &launch_info) const;
595
596 std::optional<MemoryRegionInfo> GetOpaqueTypeFromSBMemoryRegionInfo(
597 const lldb::SBMemoryRegionInfo &mem_region) const;
598
599protected:
602 lldb::ScriptedPlatformInterfaceUP m_scripted_platform_interface_up;
603};
604
605} // namespace lldb_private
606
607#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:39
A class to manage flag bits.
Definition: Debugger.h:78
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
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 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 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)
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
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
ScriptLanguage
Script interpreter types.
StateType
Process and Thread States.
@ eStateStepping
Process or thread is in the process of stepping and can not be examined.
@ eSearchDepthModule
uint64_t addr_t
Definition: lldb-types.h:79
uint64_t tid_t
Definition: lldb-types.h:82