summaryrefslogtreecommitdiff
path: root/lldb/bindings/interface/SBTarget.i
diff options
context:
space:
mode:
Diffstat (limited to 'lldb/bindings/interface/SBTarget.i')
-rw-r--r--lldb/bindings/interface/SBTarget.i1070
1 files changed, 1070 insertions, 0 deletions
diff --git a/lldb/bindings/interface/SBTarget.i b/lldb/bindings/interface/SBTarget.i
new file mode 100644
index 0000000000000..371bf5c35ebd0
--- /dev/null
+++ b/lldb/bindings/interface/SBTarget.i
@@ -0,0 +1,1070 @@
+//===-- SWIG Interface for SBTarget -----------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+namespace lldb {
+
+%feature("docstring",
+"Represents the target program running under the debugger.
+
+SBTarget supports module, breakpoint, and watchpoint iterations. For example,
+
+ for m in target.module_iter():
+ print m
+
+produces:
+
+(x86_64) /Volumes/data/lldb/svn/trunk/test/python_api/lldbutil/iter/a.out
+(x86_64) /usr/lib/dyld
+(x86_64) /usr/lib/libstdc++.6.dylib
+(x86_64) /usr/lib/libSystem.B.dylib
+(x86_64) /usr/lib/system/libmathCommon.A.dylib
+(x86_64) /usr/lib/libSystem.B.dylib(__commpage)
+
+and,
+
+ for b in target.breakpoint_iter():
+ print b
+
+produces:
+
+SBBreakpoint: id = 1, file ='main.cpp', line = 66, locations = 1
+SBBreakpoint: id = 2, file ='main.cpp', line = 85, locations = 1
+
+and,
+
+ for wp_loc in target.watchpoint_iter():
+ print wp_loc
+
+produces:
+
+Watchpoint 1: addr = 0x1034ca048 size = 4 state = enabled type = rw
+ declare @ '/Volumes/data/lldb/svn/trunk/test/python_api/watchpoint/main.c:12'
+ hw_index = 0 hit_count = 2 ignore_count = 0"
+) SBTarget;
+class SBTarget
+{
+public:
+ //------------------------------------------------------------------
+ // Broadcaster bits.
+ //------------------------------------------------------------------
+ enum
+ {
+ eBroadcastBitBreakpointChanged = (1 << 0),
+ eBroadcastBitModulesLoaded = (1 << 1),
+ eBroadcastBitModulesUnloaded = (1 << 2),
+ eBroadcastBitWatchpointChanged = (1 << 3),
+ eBroadcastBitSymbolsLoaded = (1 << 4)
+ };
+
+ //------------------------------------------------------------------
+ // Constructors
+ //------------------------------------------------------------------
+ SBTarget ();
+
+ SBTarget (const lldb::SBTarget& rhs);
+
+ //------------------------------------------------------------------
+ // Destructor
+ //------------------------------------------------------------------
+ ~SBTarget();
+
+ static const char *
+ GetBroadcasterClassName ();
+
+ bool
+ IsValid() const;
+
+ explicit operator bool() const;
+
+ static bool
+ EventIsTargetEvent (const lldb::SBEvent &event);
+
+ static lldb::SBTarget
+ GetTargetFromEvent (const lldb::SBEvent &event);
+
+ static uint32_t
+ GetNumModulesFromEvent (const lldb::SBEvent &event);
+
+ static lldb::SBModule
+ GetModuleAtIndexFromEvent (const uint32_t idx, const lldb::SBEvent &event);
+
+ lldb::SBProcess
+ GetProcess ();
+
+
+ %feature("docstring", "
+ Return the platform object associated with the target.
+
+ After return, the platform object should be checked for
+ validity.
+
+ @return
+ A platform object.") GetPlatform;
+ lldb::SBPlatform
+ GetPlatform ();
+
+ %feature("docstring", "
+ Install any binaries that need to be installed.
+
+ This function does nothing when debugging on the host system.
+ When connected to remote platforms, the target's main executable
+ and any modules that have their install path set will be
+ installed on the remote platform. If the main executable doesn't
+ have an install location set, it will be installed in the remote
+ platform's working directory.
+
+ @return
+ An error describing anything that went wrong during
+ installation.") Install;
+ lldb::SBError
+ Install();
+
+ %feature("docstring", "
+ Launch a new process.
+
+ Launch a new process by spawning a new process using the
+ target object's executable module's file as the file to launch.
+ Arguments are given in argv, and the environment variables
+ are in envp. Standard input and output files can be
+ optionally re-directed to stdin_path, stdout_path, and
+ stderr_path.
+
+ @param[in] listener
+ An optional listener that will receive all process events.
+ If listener is valid then listener will listen to all
+ process events. If not valid, then this target's debugger
+ (SBTarget::GetDebugger()) will listen to all process events.
+
+ @param[in] argv
+ The argument array.
+
+ @param[in] envp
+ The environment array.
+
+ @param[in] launch_flags
+ Flags to modify the launch (@see lldb::LaunchFlags)
+
+ @param[in] stdin_path
+ The path to use when re-directing the STDIN of the new
+ process. If all stdXX_path arguments are NULL, a pseudo
+ terminal will be used.
+
+ @param[in] stdout_path
+ The path to use when re-directing the STDOUT of the new
+ process. If all stdXX_path arguments are NULL, a pseudo
+ terminal will be used.
+
+ @param[in] stderr_path
+ The path to use when re-directing the STDERR of the new
+ process. If all stdXX_path arguments are NULL, a pseudo
+ terminal will be used.
+
+ @param[in] working_directory
+ The working directory to have the child process run in
+
+ @param[in] launch_flags
+ Some launch options specified by logical OR'ing
+ lldb::LaunchFlags enumeration values together.
+
+ @param[in] stop_at_entry
+ If false do not stop the inferior at the entry point.
+
+ @param[out]
+ An error object. Contains the reason if there is some failure.
+
+ @return
+ A process object for the newly created process.
+
+ For example,
+
+ process = target.Launch(self.dbg.GetListener(), None, None,
+ None, '/tmp/stdout.txt', None,
+ None, 0, False, error)
+
+ launches a new process by passing nothing for both the args and the envs
+ and redirect the standard output of the inferior to the /tmp/stdout.txt
+ file. It does not specify a working directory so that the debug server
+ will use its idea of what the current working directory is for the
+ inferior. Also, we ask the debugger not to stop the inferior at the
+ entry point. If no breakpoint is specified for the inferior, it should
+ run to completion if no user interaction is required.") Launch;
+ lldb::SBProcess
+ Launch (SBListener &listener,
+ char const **argv,
+ char const **envp,
+ const char *stdin_path,
+ const char *stdout_path,
+ const char *stderr_path,
+ const char *working_directory,
+ uint32_t launch_flags, // See LaunchFlags
+ bool stop_at_entry,
+ lldb::SBError& error);
+
+ %feature("docstring", "
+ Launch a new process with sensible defaults.
+
+ @param[in] argv
+ The argument array.
+
+ @param[in] envp
+ The environment array.
+
+ @param[in] working_directory
+ The working directory to have the child process run in
+
+ Default: listener
+ Set to the target's debugger (SBTarget::GetDebugger())
+
+ Default: launch_flags
+ Empty launch flags
+
+ Default: stdin_path
+ Default: stdout_path
+ Default: stderr_path
+ A pseudo terminal will be used.
+
+ @return
+ A process object for the newly created process.
+
+ For example,
+
+ process = target.LaunchSimple(['X', 'Y', 'Z'], None, os.getcwd())
+
+ launches a new process by passing 'X', 'Y', 'Z' as the args to the
+ executable.") LaunchSimple;
+ lldb::SBProcess
+ LaunchSimple (const char **argv,
+ const char **envp,
+ const char *working_directory);
+
+ lldb::SBProcess
+ Launch (lldb::SBLaunchInfo &launch_info, lldb::SBError& error);
+
+ %feature("docstring", "
+ Load a core file
+
+ @param[in] core_file
+ File path of the core dump.
+
+ @param[out] error
+ An error explaining what went wrong if the operation fails.
+ (Optional)
+
+ @return
+ A process object for the newly created core file.
+
+ For example,
+
+ process = target.LoadCore('./a.out.core')
+
+ loads a new core file and returns the process object.") LoadCore;
+ lldb::SBProcess
+ LoadCore(const char *core_file);
+
+ lldb::SBProcess
+ LoadCore(const char *core_file, lldb::SBError &error);
+
+ lldb::SBProcess
+ Attach(lldb::SBAttachInfo &attach_info, lldb::SBError& error);
+
+ %feature("docstring", "
+ Attach to process with pid.
+
+ @param[in] listener
+ An optional listener that will receive all process events.
+ If listener is valid then listener will listen to all
+ process events. If not valid, then this target's debugger
+ (SBTarget::GetDebugger()) will listen to all process events.
+
+ @param[in] pid
+ The process ID to attach to.
+
+ @param[out]
+ An error explaining what went wrong if attach fails.
+
+ @return
+ A process object for the attached process.") AttachToProcessWithID;
+ lldb::SBProcess
+ AttachToProcessWithID (SBListener &listener,
+ lldb::pid_t pid,
+ lldb::SBError& error);
+
+ %feature("docstring", "
+ Attach to process with name.
+
+ @param[in] listener
+ An optional listener that will receive all process events.
+ If listener is valid then listener will listen to all
+ process events. If not valid, then this target's debugger
+ (SBTarget::GetDebugger()) will listen to all process events.
+
+ @param[in] name
+ Basename of process to attach to.
+
+ @param[in] wait_for
+ If true wait for a new instance of 'name' to be launched.
+
+ @param[out]
+ An error explaining what went wrong if attach fails.
+
+ @return
+ A process object for the attached process.") AttachToProcessWithName;
+ lldb::SBProcess
+ AttachToProcessWithName (SBListener &listener,
+ const char *name,
+ bool wait_for,
+ lldb::SBError& error);
+
+ %feature("docstring", "
+ Connect to a remote debug server with url.
+
+ @param[in] listener
+ An optional listener that will receive all process events.
+ If listener is valid then listener will listen to all
+ process events. If not valid, then this target's debugger
+ (SBTarget::GetDebugger()) will listen to all process events.
+
+ @param[in] url
+ The url to connect to, e.g., 'connect://localhost:12345'.
+
+ @param[in] plugin_name
+ The plugin name to be used; can be NULL.
+
+ @param[out]
+ An error explaining what went wrong if the connect fails.
+
+ @return
+ A process object for the connected process.") ConnectRemote;
+ lldb::SBProcess
+ ConnectRemote (SBListener &listener,
+ const char *url,
+ const char *plugin_name,
+ SBError& error);
+
+ lldb::SBFileSpec
+ GetExecutable ();
+
+ %feature("docstring", "
+ Append the path mapping (from -> to) to the target's paths mapping list.") AppendImageSearchPath;
+ void
+ AppendImageSearchPath (const char *from,
+ const char *to,
+ SBError &error);
+
+ bool
+ AddModule (lldb::SBModule &module);
+
+ lldb::SBModule
+ AddModule (const char *path,
+ const char *triple,
+ const char *uuid);
+
+ lldb::SBModule
+ AddModule (const char *path,
+ const char *triple,
+ const char *uuid_cstr,
+ const char *symfile);
+
+ lldb::SBModule
+ AddModule (const SBModuleSpec &module_spec);
+
+ uint32_t
+ GetNumModules () const;
+
+ lldb::SBModule
+ GetModuleAtIndex (uint32_t idx);
+
+ bool
+ RemoveModule (lldb::SBModule module);
+
+ lldb::SBDebugger
+ GetDebugger() const;
+
+ lldb::SBModule
+ FindModule (const lldb::SBFileSpec &file_spec);
+
+ %feature("docstring", "
+ Find compile units related to *this target and passed source
+ file.
+
+ @param[in] sb_file_spec
+ A lldb::SBFileSpec object that contains source file
+ specification.
+
+ @return
+ A lldb::SBSymbolContextList that gets filled in with all of
+ the symbol contexts for all the matches.") FindCompileUnits;
+ lldb::SBSymbolContextList
+ FindCompileUnits (const lldb::SBFileSpec &sb_file_spec);
+
+ lldb::ByteOrder
+ GetByteOrder ();
+
+ uint32_t
+ GetAddressByteSize();
+
+ const char *
+ GetTriple ();
+
+ %feature("docstring", "
+ Architecture data byte width accessor
+
+ @return
+ The size in 8-bit (host) bytes of a minimum addressable
+ unit from the Architecture's data bus") GetDataByteSize;
+ uint32_t
+ GetDataByteSize ();
+
+ %feature("docstring", "
+ Architecture code byte width accessor
+
+ @return
+ The size in 8-bit (host) bytes of a minimum addressable
+ unit from the Architecture's code bus") GetCodeByteSize;
+ uint32_t
+ GetCodeByteSize ();
+
+ lldb::SBError
+ SetSectionLoadAddress (lldb::SBSection section,
+ lldb::addr_t section_base_addr);
+
+ lldb::SBError
+ ClearSectionLoadAddress (lldb::SBSection section);
+
+ lldb::SBError
+ SetModuleLoadAddress (lldb::SBModule module,
+ int64_t sections_offset);
+
+ lldb::SBError
+ ClearModuleLoadAddress (lldb::SBModule module);
+
+ %feature("docstring", "
+ Find functions by name.
+
+ @param[in] name
+ The name of the function we are looking for.
+
+ @param[in] name_type_mask
+ A logical OR of one or more FunctionNameType enum bits that
+ indicate what kind of names should be used when doing the
+ lookup. Bits include fully qualified names, base names,
+ C++ methods, or ObjC selectors.
+ See FunctionNameType for more details.
+
+ @return
+ A lldb::SBSymbolContextList that gets filled in with all of
+ the symbol contexts for all the matches.") FindFunctions;
+ lldb::SBSymbolContextList
+ FindFunctions (const char *name,
+ uint32_t name_type_mask = lldb::eFunctionNameTypeAny);
+
+ lldb::SBType
+ FindFirstType (const char* type);
+
+ lldb::SBTypeList
+ FindTypes (const char* type);
+
+ lldb::SBType
+ GetBasicType(lldb::BasicType type);
+
+ lldb::SBSourceManager
+ GetSourceManager ();
+
+ %feature("docstring", "
+ Find global and static variables by name.
+
+ @param[in] name
+ The name of the global or static variable we are looking
+ for.
+
+ @param[in] max_matches
+ Allow the number of matches to be limited to max_matches.
+
+ @return
+ A list of matched variables in an SBValueList.") FindGlobalVariables;
+ lldb::SBValueList
+ FindGlobalVariables (const char *name,
+ uint32_t max_matches);
+
+ %feature("docstring", "
+ Find the first global (or static) variable by name.
+
+ @param[in] name
+ The name of the global or static variable we are looking
+ for.
+
+ @return
+ An SBValue that gets filled in with the found variable (if any).") FindFirstGlobalVariable;
+ lldb::SBValue
+ FindFirstGlobalVariable (const char* name);
+
+
+ lldb::SBValueList
+ FindGlobalVariables(const char *name,
+ uint32_t max_matches,
+ MatchType matchtype);
+
+ lldb::SBSymbolContextList
+ FindGlobalFunctions(const char *name,
+ uint32_t max_matches,
+ MatchType matchtype);
+
+ void
+ Clear ();
+
+ %feature("docstring", "
+ Resolve a current file address into a section offset address.
+
+ @param[in] file_addr
+
+ @return
+ An SBAddress which will be valid if...") ResolveFileAddress;
+ lldb::SBAddress
+ ResolveFileAddress (lldb::addr_t file_addr);
+
+ lldb::SBAddress
+ ResolveLoadAddress (lldb::addr_t vm_addr);
+
+ lldb::SBAddress
+ ResolvePastLoadAddress (uint32_t stop_id, lldb::addr_t vm_addr);
+
+ SBSymbolContext
+ ResolveSymbolContextForAddress (const SBAddress& addr,
+ uint32_t resolve_scope);
+
+ %feature("docstring", "
+ Read target memory. If a target process is running then memory
+ is read from here. Otherwise the memory is read from the object
+ files. For a target whose bytes are sized as a multiple of host
+ bytes, the data read back will preserve the target's byte order.
+
+ @param[in] addr
+ A target address to read from.
+
+ @param[out] buf
+ The buffer to read memory into.
+
+ @param[in] size
+ The maximum number of host bytes to read in the buffer passed
+ into this call
+
+ @param[out] error
+ Error information is written here if the memory read fails.
+
+ @return
+ The amount of data read in host bytes.") ReadMemory;
+ size_t
+ ReadMemory (const SBAddress addr, void *buf, size_t size, lldb::SBError &error);
+
+ lldb::SBBreakpoint
+ BreakpointCreateByLocation (const char *file, uint32_t line);
+
+ lldb::SBBreakpoint
+ BreakpointCreateByLocation (const lldb::SBFileSpec &file_spec, uint32_t line);
+
+ lldb::SBBreakpoint
+ BreakpointCreateByLocation (const lldb::SBFileSpec &file_spec, uint32_t line, lldb::addr_t offset);
+
+ lldb::SBBreakpoint
+ BreakpointCreateByLocation (const lldb::SBFileSpec &file_spec, uint32_t line,
+ lldb::addr_t offset, SBFileSpecList &module_list);
+
+ lldb::SBBreakpoint
+ BreakpointCreateByLocation (const lldb::SBFileSpec &file_spec, uint32_t line,
+ uint32_t column, lldb::addr_t offset,
+ SBFileSpecList &module_list);
+
+ lldb::SBBreakpoint
+ BreakpointCreateByName (const char *symbol_name, const char *module_name = NULL);
+
+ lldb::SBBreakpoint
+ BreakpointCreateByName (const char *symbol_name,
+ uint32_t func_name_type, // Logical OR one or more FunctionNameType enum bits
+ const SBFileSpecList &module_list,
+ const SBFileSpecList &comp_unit_list);
+
+ lldb::SBBreakpoint
+ BreakpointCreateByName (const char *symbol_name,
+ uint32_t func_name_type, // Logical OR one or more FunctionNameType enum bits
+ lldb::LanguageType symbol_language,
+ const SBFileSpecList &module_list,
+ const SBFileSpecList &comp_unit_list);
+
+#ifdef SWIGPYTHON
+%typemap(in) (const char **symbol_name, uint32_t num_names) {
+ using namespace lldb_private;
+ /* Check if is a list */
+ if (PythonList::Check($input)) {
+ PythonList list(PyRefType::Borrowed, $input);
+ $2 = list.GetSize();
+ int i = 0;
+ $1 = (char**)malloc(($2+1)*sizeof(char*));
+ for (i = 0; i < $2; i++) {
+ PythonString py_str = list.GetItemAtIndex(i).AsType<PythonString>();
+ if (!py_str.IsAllocated()) {
+ PyErr_SetString(PyExc_TypeError,"list must contain strings and blubby");
+ free($1);
+ return nullptr;
+ }
+
+ $1[i] = const_cast<char*>(py_str.GetString().data());
+ }
+ $1[i] = 0;
+ } else if ($input == Py_None) {
+ $1 = NULL;
+ } else {
+ PyErr_SetString(PyExc_TypeError,"not a list");
+ return NULL;
+ }
+}
+#endif
+
+ lldb::SBBreakpoint
+ BreakpointCreateByNames (const char **symbol_name,
+ uint32_t num_names,
+ uint32_t name_type_mask, // Logical OR one or more FunctionNameType enum bits
+ const SBFileSpecList &module_list,
+ const SBFileSpecList &comp_unit_list);
+
+ lldb::SBBreakpoint
+ BreakpointCreateByNames (const char **symbol_name,
+ uint32_t num_names,
+ uint32_t name_type_mask, // Logical OR one or more FunctionNameType enum bits
+ lldb::LanguageType symbol_language,
+ const SBFileSpecList &module_list,
+ const SBFileSpecList &comp_unit_list);
+
+ lldb::SBBreakpoint
+ BreakpointCreateByNames (const char **symbol_name,
+ uint32_t num_names,
+ uint32_t name_type_mask, // Logical OR one or more FunctionNameType enum bits
+ lldb::LanguageType symbol_language,
+ lldb::addr_t offset,
+ const SBFileSpecList &module_list,
+ const SBFileSpecList &comp_unit_list);
+
+ lldb::SBBreakpoint
+ BreakpointCreateByRegex (const char *symbol_name_regex, const char *module_name = NULL);
+
+ lldb::SBBreakpoint
+ BreakpointCreateByRegex (const char *symbol_name_regex,
+ lldb::LanguageType symbol_language,
+ const SBFileSpecList &module_list,
+ const SBFileSpecList &comp_unit_list);
+
+ lldb::SBBreakpoint
+ BreakpointCreateBySourceRegex (const char *source_regex, const lldb::SBFileSpec &source_file, const char *module_name = NULL);
+
+ lldb::SBBreakpoint
+ BreakpointCreateBySourceRegex (const char *source_regex, const lldb::SBFileSpecList &module_list, const lldb::SBFileSpecList &file_list);
+
+ lldb::SBBreakpoint
+ BreakpointCreateBySourceRegex (const char *source_regex,
+ const SBFileSpecList &module_list,
+ const SBFileSpecList &source_file,
+ const SBStringList &func_names);
+
+ lldb::SBBreakpoint
+ BreakpointCreateForException (lldb::LanguageType language,
+ bool catch_bp,
+ bool throw_bp);
+
+ lldb::SBBreakpoint
+ BreakpointCreateByAddress (addr_t address);
+
+ lldb::SBBreakpoint
+ BreakpointCreateBySBAddress (SBAddress &sb_address);
+
+ %feature("docstring", "
+ Create a breakpoint using a scripted resolver.
+
+ @param[in] class_name
+ This is the name of the class that implements a scripted resolver.
+ The class should have the following signature:
+ class Resolver:
+ def __init__(self, bkpt, extra_args):
+ # bkpt - the breakpoint for which this is the resolver. When
+ # the resolver finds an interesting address, call AddLocation
+ # on this breakpoint to add it.
+ #
+ # extra_args - an SBStructuredData that can be used to
+ # parametrize this instance. Same as the extra_args passed
+ # to BreakpointCreateFromScript.
+
+ def __get_depth__ (self):
+ # This is optional, but if defined, you should return the
+ # depth at which you want the callback to be called. The
+ # available options are:
+ # lldb.eSearchDepthModule
+ # lldb.eSearchDepthCompUnit
+ # The default if you don't implement this method is
+ # eSearchDepthModule.
+
+ def __callback__(self, sym_ctx):
+ # sym_ctx - an SBSymbolContext that is the cursor in the
+ # search through the program to resolve breakpoints.
+ # The sym_ctx will be filled out to the depth requested in
+ # __get_depth__.
+ # Look in this sym_ctx for new breakpoint locations,
+ # and if found use bkpt.AddLocation to add them.
+ # Note, you will only get called for modules/compile_units that
+ # pass the SearchFilter provided by the module_list & file_list
+ # passed into BreakpointCreateFromScript.
+
+ def get_short_help(self):
+ # Optional, but if implemented return a short string that will
+ # be printed at the beginning of the break list output for the
+ # breakpoint.
+
+ @param[in] extra_args
+ This is an SBStructuredData object that will get passed to the
+ constructor of the class in class_name. You can use this to
+ reuse the same class, parametrizing it with entries from this
+ dictionary.
+
+ @param module_list
+ If this is non-empty, this will be used as the module filter in the
+ SearchFilter created for this breakpoint.
+
+ @param file_list
+ If this is non-empty, this will be used as the comp unit filter in the
+ SearchFilter created for this breakpoint.
+
+ @return
+ An SBBreakpoint that will set locations based on the logic in the
+ resolver's search callback.") BreakpointCreateFromScript;
+ lldb::SBBreakpoint BreakpointCreateFromScript(
+ const char *class_name,
+ SBStructuredData &extra_args,
+ const SBFileSpecList &module_list,
+ const SBFileSpecList &file_list,
+ bool request_hardware = false);
+
+ uint32_t
+ GetNumBreakpoints () const;
+
+ lldb::SBBreakpoint
+ GetBreakpointAtIndex (uint32_t idx) const;
+
+ bool
+ BreakpointDelete (break_id_t break_id);
+
+ lldb::SBBreakpoint
+ FindBreakpointByID (break_id_t break_id);
+
+
+ bool FindBreakpointsByName(const char *name, SBBreakpointList &bkpt_list);
+
+ void DeleteBreakpointName(const char *name);
+
+ void GetBreakpointNames(SBStringList &names);
+
+ bool
+ EnableAllBreakpoints ();
+
+ bool
+ DisableAllBreakpoints ();
+
+ bool
+ DeleteAllBreakpoints ();
+
+ %feature("docstring", "
+ Read breakpoints from source_file and return the newly created
+ breakpoints in bkpt_list.
+
+ @param[in] source_file
+ The file from which to read the breakpoints
+
+ @param[out] bkpt_list
+ A list of the newly created breakpoints.
+
+ @return
+ An SBError detailing any errors in reading in the breakpoints.") BreakpointsCreateFromFile;
+ lldb::SBError
+ BreakpointsCreateFromFile(SBFileSpec &source_file,
+ SBBreakpointList &bkpt_list);
+
+ %feature("docstring", "
+ Read breakpoints from source_file and return the newly created
+ breakpoints in bkpt_list.
+
+ @param[in] source_file
+ The file from which to read the breakpoints
+
+ @param[in] matching_names
+ Only read in breakpoints whose names match one of the names in this
+ list.
+
+ @param[out] bkpt_list
+ A list of the newly created breakpoints.
+
+ @return
+ An SBError detailing any errors in reading in the breakpoints.") BreakpointsCreateFromFile;
+ lldb::SBError BreakpointsCreateFromFile(SBFileSpec &source_file,
+ SBStringList &matching_names,
+ SBBreakpointList &new_bps);
+
+ %feature("docstring", "
+ Write breakpoints to dest_file.
+
+ @param[in] dest_file
+ The file to which to write the breakpoints.
+
+ @return
+ An SBError detailing any errors in writing in the breakpoints.") BreakpointsCreateFromFile;
+ lldb::SBError
+ BreakpointsWriteToFile(SBFileSpec &dest_file);
+
+ %feature("docstring", "
+ Write breakpoints listed in bkpt_list to dest_file.
+
+ @param[in] dest_file
+ The file to which to write the breakpoints.
+
+ @param[in] bkpt_list
+ Only write breakpoints from this list.
+
+ @param[in] append
+ If true, append the breakpoints in bkpt_list to the others
+ serialized in dest_file. If dest_file doesn't exist, then a new
+ file will be created and the breakpoints in bkpt_list written to it.
+
+ @return
+ An SBError detailing any errors in writing in the breakpoints.") BreakpointsCreateFromFile;
+ lldb::SBError
+ BreakpointsWriteToFile(SBFileSpec &dest_file,
+ SBBreakpointList &bkpt_list,
+ bool append = false);
+
+ uint32_t
+ GetNumWatchpoints () const;
+
+ lldb::SBWatchpoint
+ GetWatchpointAtIndex (uint32_t idx) const;
+
+ bool
+ DeleteWatchpoint (lldb::watch_id_t watch_id);
+
+ lldb::SBWatchpoint
+ FindWatchpointByID (lldb::watch_id_t watch_id);
+
+ bool
+ EnableAllWatchpoints ();
+
+ bool
+ DisableAllWatchpoints ();
+
+ bool
+ DeleteAllWatchpoints ();
+
+ lldb::SBWatchpoint
+ WatchAddress (lldb::addr_t addr,
+ size_t size,
+ bool read,
+ bool write,
+ SBError &error);
+
+
+ lldb::SBBroadcaster
+ GetBroadcaster () const;
+
+ %feature("docstring", "
+ Create an SBValue with the given name by treating the memory starting at addr as an entity of type.
+
+ @param[in] name
+ The name of the resultant SBValue
+
+ @param[in] addr
+ The address of the start of the memory region to be used.
+
+ @param[in] type
+ The type to use to interpret the memory starting at addr.
+
+ @return
+ An SBValue of the given type, may be invalid if there was an error reading
+ the underlying memory.") CreateValueFromAddress;
+ lldb::SBValue
+ CreateValueFromAddress (const char *name, lldb::SBAddress addr, lldb::SBType type);
+
+ lldb::SBValue
+ CreateValueFromData (const char *name, lldb::SBData data, lldb::SBType type);
+
+ lldb::SBValue
+ CreateValueFromExpression (const char *name, const char* expr);
+
+ %feature("docstring", "
+ Disassemble a specified number of instructions starting at an address.
+ Parameters:
+ base_addr -- the address to start disassembly from
+ count -- the number of instructions to disassemble
+ flavor_string -- may be 'intel' or 'att' on x86 targets to specify that style of disassembly
+ Returns an SBInstructionList.")
+ ReadInstructions;
+ lldb::SBInstructionList
+ ReadInstructions (lldb::SBAddress base_addr, uint32_t count);
+
+ lldb::SBInstructionList
+ ReadInstructions (lldb::SBAddress base_addr, uint32_t count, const char *flavor_string);
+
+ %feature("docstring", "
+ Disassemble the bytes in a buffer and return them in an SBInstructionList.
+ Parameters:
+ base_addr -- used for symbolicating the offsets in the byte stream when disassembling
+ buf -- bytes to be disassembled
+ size -- (C++) size of the buffer
+ Returns an SBInstructionList.")
+ GetInstructions;
+ lldb::SBInstructionList
+ GetInstructions (lldb::SBAddress base_addr, const void *buf, size_t size);
+
+ %feature("docstring", "
+ Disassemble the bytes in a buffer and return them in an SBInstructionList, with a supplied flavor.
+ Parameters:
+ base_addr -- used for symbolicating the offsets in the byte stream when disassembling
+ flavor -- may be 'intel' or 'att' on x86 targets to specify that style of disassembly
+ buf -- bytes to be disassembled
+ size -- (C++) size of the buffer
+ Returns an SBInstructionList.")
+ GetInstructionsWithFlavor;
+ lldb::SBInstructionList
+ GetInstructionsWithFlavor (lldb::SBAddress base_addr, const char *flavor_string, const void *buf, size_t size);
+
+ lldb::SBSymbolContextList
+ FindSymbols (const char *name, lldb::SymbolType type = eSymbolTypeAny);
+
+ bool
+ GetDescription (lldb::SBStream &description, lldb::DescriptionLevel description_level);
+
+ lldb::addr_t
+ GetStackRedZoneSize();
+
+ lldb::SBLaunchInfo
+ GetLaunchInfo () const;
+
+ void
+ SetLaunchInfo (const lldb::SBLaunchInfo &launch_info);
+
+ void SetCollectingStats(bool v);
+
+ bool GetCollectingStats();
+
+ lldb::SBStructuredData GetStatistics();
+
+ bool
+ operator == (const lldb::SBTarget &rhs) const;
+
+ bool
+ operator != (const lldb::SBTarget &rhs) const;
+
+ lldb::SBValue
+ EvaluateExpression (const char *expr);
+
+ lldb::SBValue
+ EvaluateExpression (const char *expr, const lldb::SBExpressionOptions &options);
+
+ STRING_EXTENSION_LEVEL(SBTarget, lldb::eDescriptionLevelBrief)
+
+#ifdef SWIGPYTHON
+ %pythoncode %{
+ class modules_access(object):
+ '''A helper object that will lazily hand out lldb.SBModule objects for a target when supplied an index, or by full or partial path.'''
+ def __init__(self, sbtarget):
+ self.sbtarget = sbtarget
+
+ def __len__(self):
+ if self.sbtarget:
+ return int(self.sbtarget.GetNumModules())
+ return 0
+
+ def __getitem__(self, key):
+ num_modules = self.sbtarget.GetNumModules()
+ if type(key) is int:
+ if key < num_modules:
+ return self.sbtarget.GetModuleAtIndex(key)
+ elif type(key) is str:
+ if key.find('/') == -1:
+ for idx in range(num_modules):
+ module = self.sbtarget.GetModuleAtIndex(idx)
+ if module.file.basename == key:
+ return module
+ else:
+ for idx in range(num_modules):
+ module = self.sbtarget.GetModuleAtIndex(idx)
+ if module.file.fullpath == key:
+ return module
+ # See if the string is a UUID
+ try:
+ the_uuid = uuid.UUID(key)
+ if the_uuid:
+ for idx in range(num_modules):
+ module = self.sbtarget.GetModuleAtIndex(idx)
+ if module.uuid == the_uuid:
+ return module
+ except:
+ return None
+ elif type(key) is uuid.UUID:
+ for idx in range(num_modules):
+ module = self.sbtarget.GetModuleAtIndex(idx)
+ if module.uuid == key:
+ return module
+ elif type(key) is re.SRE_Pattern:
+ matching_modules = []
+ for idx in range(num_modules):
+ module = self.sbtarget.GetModuleAtIndex(idx)
+ re_match = key.search(module.path.fullpath)
+ if re_match:
+ matching_modules.append(module)
+ return matching_modules
+ else:
+ print("error: unsupported item type: %s" % type(key))
+ return None
+
+ def get_modules_access_object(self):
+ '''An accessor function that returns a modules_access() object which allows lazy module access from a lldb.SBTarget object.'''
+ return self.modules_access (self)
+
+ def get_modules_array(self):
+ '''An accessor function that returns a list() that contains all modules in a lldb.SBTarget object.'''
+ modules = []
+ for idx in range(self.GetNumModules()):
+ modules.append(self.GetModuleAtIndex(idx))
+ return modules
+
+ def module_iter(self):
+ '''Returns an iterator over all modules in a lldb.SBTarget
+ object.'''
+ return lldb_iter(self, 'GetNumModules', 'GetModuleAtIndex')
+
+ def breakpoint_iter(self):
+ '''Returns an iterator over all breakpoints in a lldb.SBTarget
+ object.'''
+ return lldb_iter(self, 'GetNumBreakpoints', 'GetBreakpointAtIndex')
+
+ def watchpoint_iter(self):
+ '''Returns an iterator over all watchpoints in a lldb.SBTarget
+ object.'''
+ return lldb_iter(self, 'GetNumWatchpoints', 'GetWatchpointAtIndex')
+
+ modules = property(get_modules_array, None, doc='''A read only property that returns a list() of lldb.SBModule objects contained in this target. This list is a list all modules that the target currently is tracking (the main executable and all dependent shared libraries).''')
+ module = property(get_modules_access_object, None, doc=r'''A read only property that returns an object that implements python operator overloading with the square brackets().\n target.module[<int>] allows array access to any modules.\n target.module[<str>] allows access to modules by basename, full path, or uuid string value.\n target.module[uuid.UUID()] allows module access by UUID.\n target.module[re] allows module access using a regular expression that matches the module full path.''')
+ process = property(GetProcess, None, doc='''A read only property that returns an lldb object that represents the process (lldb.SBProcess) that this target owns.''')
+ executable = property(GetExecutable, None, doc='''A read only property that returns an lldb object that represents the main executable module (lldb.SBModule) for this target.''')
+ debugger = property(GetDebugger, None, doc='''A read only property that returns an lldb object that represents the debugger (lldb.SBDebugger) that owns this target.''')
+ num_breakpoints = property(GetNumBreakpoints, None, doc='''A read only property that returns the number of breakpoints that this target has as an integer.''')
+ num_watchpoints = property(GetNumWatchpoints, None, doc='''A read only property that returns the number of watchpoints that this target has as an integer.''')
+ broadcaster = property(GetBroadcaster, None, doc='''A read only property that an lldb object that represents the broadcaster (lldb.SBBroadcaster) for this target.''')
+ byte_order = property(GetByteOrder, None, doc='''A read only property that returns an lldb enumeration value (lldb.eByteOrderLittle, lldb.eByteOrderBig, lldb.eByteOrderInvalid) that represents the byte order for this target.''')
+ addr_size = property(GetAddressByteSize, None, doc='''A read only property that returns the size in bytes of an address for this target.''')
+ triple = property(GetTriple, None, doc='''A read only property that returns the target triple (arch-vendor-os) for this target as a string.''')
+ data_byte_size = property(GetDataByteSize, None, doc='''A read only property that returns the size in host bytes of a byte in the data address space for this target.''')
+ code_byte_size = property(GetCodeByteSize, None, doc='''A read only property that returns the size in host bytes of a byte in the code address space for this target.''')
+ platform = property(GetPlatform, None, doc='''A read only property that returns the platform associated with with this target.''')
+ %}
+#endif
+};
+} // namespace lldb