| //===-- SWIG Interface for SBTarget -----------------------------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| namespace lldb { |
| |
| %feature("docstring", |
| "Represents the target program running under the debugger. |
| |
| SBTarget supports module, breakpoint, and watchpoint_location 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_location_iter(): |
| print wp_loc |
| |
| produces: |
| |
| WatchpointLocation 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 callback = 0x0 baton = 0x0" |
| ) SBTarget; |
| class SBTarget |
| { |
| public: |
| //------------------------------------------------------------------ |
| // Broadcaster bits. |
| //------------------------------------------------------------------ |
| enum |
| { |
| eBroadcastBitBreakpointChanged = (1 << 0), |
| eBroadcastBitModulesLoaded = (1 << 1), |
| eBroadcastBitModulesUnloaded = (1 << 2) |
| }; |
| |
| //------------------------------------------------------------------ |
| // Constructors |
| //------------------------------------------------------------------ |
| SBTarget (); |
| |
| SBTarget (const lldb::SBTarget& rhs); |
| |
| //------------------------------------------------------------------ |
| // Destructor |
| //------------------------------------------------------------------ |
| ~SBTarget(); |
| |
| bool |
| IsValid() const; |
| |
| lldb::SBProcess |
| GetProcess (); |
| |
| %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 \a argv, and the environment variables |
| /// are in \a envp. Standard input and output files can be |
| /// optionally re-directed to \a stdin_path, \a stdout_path, and |
| /// \a stderr_path. |
| /// |
| /// @param[in] listener |
| /// An optional listener that will receive all process events. |
| /// If \a listener is valid then \a 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_endtry |
| /// 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); |
| |
| %feature("docstring", " |
| //------------------------------------------------------------------ |
| /// Attach to process with pid. |
| /// |
| /// @param[in] listener |
| /// An optional listener that will receive all process events. |
| /// If \a listener is valid then \a 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 \a listener is valid then \a 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 \a listener is valid then \a 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 (); |
| |
| bool |
| AddModule (lldb::SBModule &module); |
| |
| lldb::SBModule |
| AddModule (const char *path, |
| const char *triple, |
| const char *uuid); |
| |
| 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); |
| |
| 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. |
| /// |
| /// @param[in] append |
| /// If true, any matches will be appended to \a sc_list, else |
| /// matches replace the contents of \a sc_list. |
| /// |
| /// @param[out] sc_list |
| /// A symbol context list that gets filled in with all of the |
| /// matches. |
| /// |
| /// @return |
| /// The number of matches added to \a sc_list. |
| //------------------------------------------------------------------ |
| ") FindFunctions; |
| uint32_t |
| FindFunctions (const char *name, |
| uint32_t name_type_mask, // Logical OR one or more FunctionNameType enum bits |
| bool append, |
| lldb::SBSymbolContextList& sc_list); |
| |
| lldb::SBType |
| FindFirstType (const char* type); |
| |
| lldb::SBTypeList |
| FindTypes (const char* 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 \a max_matches. |
| /// |
| /// @return |
| /// A list of matched variables in an SBValueList. |
| //------------------------------------------------------------------ |
| ") FindGlobalVariables; |
| lldb::SBValueList |
| FindGlobalVariables (const char *name, |
| uint32_t max_matches); |
| |
| void |
| Clear (); |
| |
| lldb::SBAddress |
| ResolveLoadAddress (lldb::addr_t vm_addr); |
| |
| SBSymbolContext |
| ResolveSymbolContextForAddress (const SBAddress& addr, |
| uint32_t resolve_scope); |
| |
| lldb::SBBreakpoint |
| BreakpointCreateByLocation (const char *file, uint32_t line); |
| |
| lldb::SBBreakpoint |
| BreakpointCreateByLocation (const lldb::SBFileSpec &file_spec, uint32_t line); |
| |
| lldb::SBBreakpoint |
| BreakpointCreateByName (const char *symbol_name, const char *module_name = NULL); |
| |
| lldb::SBBreakpoint |
| BreakpointCreateByRegex (const char *symbol_name_regex, const char *module_name = NULL); |
| |
| lldb::SBBreakpoint |
| BreakpointCreateBySourceRegex (const char *source_regex, const lldb::SBFileSpec &source_file, const char *module_name = NULL); |
| |
| lldb::SBBreakpoint |
| BreakpointCreateByAddress (addr_t address); |
| |
| 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 |
| EnableAllBreakpoints (); |
| |
| bool |
| DisableAllBreakpoints (); |
| |
| bool |
| DeleteAllBreakpoints (); |
| |
| uint32_t |
| GetNumWatchpointLocations () const; |
| |
| lldb::SBWatchpointLocation |
| GetLastCreatedWatchpointLocation (); |
| |
| lldb::SBWatchpointLocation |
| GetWatchpointLocationAtIndex (uint32_t idx) const; |
| |
| bool |
| WatchpointLocationDelete (watch_id_t watch_id); |
| |
| lldb::SBWatchpointLocation |
| FindWatchpointLocationByID (watch_id_t watch_id); |
| |
| bool |
| EnableAllWatchpointLocations (); |
| |
| bool |
| DisableAllWatchpointLocations (); |
| |
| bool |
| DeleteAllWatchpointLocations (); |
| |
| lldb::SBBroadcaster |
| GetBroadcaster () const; |
| |
| bool |
| GetDescription (lldb::SBStream &description, lldb::DescriptionLevel description_level) const; |
| }; |
| |
| } // namespace lldb |