1 //===-- SWIG Interface for SBTarget -----------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
14 "Represents the target program running under the debugger.
16 SBTarget supports module, breakpoint, and watchpoint iterations. For example,
18 for m in target.module_iter():
23 (x86_64) /Volumes/data/lldb/svn/trunk/test/python_api/lldbutil/iter/a.out
24 (x86_64) /usr/lib/dyld
25 (x86_64) /usr/lib/libstdc++.6.dylib
26 (x86_64) /usr/lib/libSystem.B.dylib
27 (x86_64) /usr/lib/system/libmathCommon.A.dylib
28 (x86_64) /usr/lib/libSystem.B.dylib(__commpage)
32 for b in target.breakpoint_iter():
37 SBBreakpoint: id = 1, file ='main.cpp', line = 66, locations = 1
38 SBBreakpoint: id = 2, file ='main.cpp', line = 85, locations = 1
42 for wp_loc in target.watchpoint_iter():
47 Watchpoint 1: addr = 0x1034ca048 size = 4 state = enabled type = rw
48 declare @ '/Volumes/data/lldb/svn/trunk/test/python_api/watchpoint/main.c:12'
49 hw_index = 0 hit_count = 2 ignore_count = 0"
54 //------------------------------------------------------------------
56 //------------------------------------------------------------------
59 eBroadcastBitBreakpointChanged = (1 << 0),
60 eBroadcastBitModulesLoaded = (1 << 1),
61 eBroadcastBitModulesUnloaded = (1 << 2),
62 eBroadcastBitWatchpointChanged = (1 << 3),
63 eBroadcastBitSymbolsLoaded = (1 << 4)
66 //------------------------------------------------------------------
68 //------------------------------------------------------------------
71 SBTarget (const lldb::SBTarget& rhs);
73 //------------------------------------------------------------------
75 //------------------------------------------------------------------
79 GetBroadcasterClassName ();
85 EventIsTargetEvent (const lldb::SBEvent &event);
88 GetTargetFromEvent (const lldb::SBEvent &event);
91 GetNumModulesFromEvent (const lldb::SBEvent &event);
94 GetModuleAtIndexFromEvent (const uint32_t idx, const lldb::SBEvent &event);
100 %feature("docstring", "
101 //------------------------------------------------------------------
102 /// Return the platform object associated with the target.
104 /// After return, the platform object should be checked for
108 /// A platform object.
109 //------------------------------------------------------------------
114 %feature("docstring", "
115 //------------------------------------------------------------------
116 /// Install any binaries that need to be installed.
118 /// This function does nothing when debugging on the host system.
119 /// When connected to remote platforms, the target's main executable
120 /// and any modules that have their install path set will be
121 /// installed on the remote platform. If the main executable doesn't
122 /// have an install location set, it will be installed in the remote
123 /// platform's working directory.
126 /// An error describing anything that went wrong during
128 //------------------------------------------------------------------
133 %feature("docstring", "
134 //------------------------------------------------------------------
135 /// Launch a new process.
137 /// Launch a new process by spawning a new process using the
138 /// target object's executable module's file as the file to launch.
139 /// Arguments are given in \a argv, and the environment variables
140 /// are in \a envp. Standard input and output files can be
141 /// optionally re-directed to \a stdin_path, \a stdout_path, and
144 /// @param[in] listener
145 /// An optional listener that will receive all process events.
146 /// If \a listener is valid then \a listener will listen to all
147 /// process events. If not valid, then this target's debugger
148 /// (SBTarget::GetDebugger()) will listen to all process events.
151 /// The argument array.
154 /// The environment array.
156 /// @param[in] launch_flags
157 /// Flags to modify the launch (@see lldb::LaunchFlags)
159 /// @param[in] stdin_path
160 /// The path to use when re-directing the STDIN of the new
161 /// process. If all stdXX_path arguments are NULL, a pseudo
162 /// terminal will be used.
164 /// @param[in] stdout_path
165 /// The path to use when re-directing the STDOUT of the new
166 /// process. If all stdXX_path arguments are NULL, a pseudo
167 /// terminal will be used.
169 /// @param[in] stderr_path
170 /// The path to use when re-directing the STDERR of the new
171 /// process. If all stdXX_path arguments are NULL, a pseudo
172 /// terminal will be used.
174 /// @param[in] working_directory
175 /// The working directory to have the child process run in
177 /// @param[in] launch_flags
178 /// Some launch options specified by logical OR'ing
179 /// lldb::LaunchFlags enumeration values together.
181 /// @param[in] stop_at_entry
182 /// If false do not stop the inferior at the entry point.
185 /// An error object. Contains the reason if there is some failure.
188 /// A process object for the newly created process.
189 //------------------------------------------------------------------
193 process = target.Launch(self.dbg.GetListener(), None, None,
194 None, '/tmp/stdout.txt', None,
195 None, 0, False, error)
197 launches a new process by passing nothing for both the args and the envs
198 and redirect the standard output of the inferior to the /tmp/stdout.txt
199 file. It does not specify a working directory so that the debug server
200 will use its idea of what the current working directory is for the
201 inferior. Also, we ask the debugger not to stop the inferior at the
202 entry point. If no breakpoint is specified for the inferior, it should
203 run to completion if no user interaction is required.
206 Launch (SBListener &listener,
209 const char *stdin_path,
210 const char *stdout_path,
211 const char *stderr_path,
212 const char *working_directory,
213 uint32_t launch_flags, // See LaunchFlags
215 lldb::SBError& error);
217 %feature("docstring", "
218 //------------------------------------------------------------------
219 /// Launch a new process with sensible defaults.
222 /// The argument array.
225 /// The environment array.
227 /// @param[in] working_directory
228 /// The working directory to have the child process run in
230 /// Default: listener
231 /// Set to the target's debugger (SBTarget::GetDebugger())
233 /// Default: launch_flags
234 /// Empty launch flags
236 /// Default: stdin_path
237 /// Default: stdout_path
238 /// Default: stderr_path
239 /// A pseudo terminal will be used.
242 /// A process object for the newly created process.
243 //------------------------------------------------------------------
247 process = target.LaunchSimple(['X', 'Y', 'Z'], None, os.getcwd())
249 launches a new process by passing 'X', 'Y', 'Z' as the args to the
253 LaunchSimple (const char **argv,
255 const char *working_directory);
258 Launch (lldb::SBLaunchInfo &launch_info, lldb::SBError& error);
260 %feature("docstring", "
261 //------------------------------------------------------------------
264 /// @param[in] core_file
265 /// File path of the core dump.
268 /// A process object for the newly created core file.
269 //------------------------------------------------------------------
273 process = target.LoadCore('./a.out.core')
275 loads a new core file and returns the process object.
278 LoadCore(const char *core_file);
281 Attach (lldb::SBAttachInfo &attach_info, lldb::SBError& error);
284 %feature("docstring", "
285 //------------------------------------------------------------------
286 /// Attach to process with pid.
288 /// @param[in] listener
289 /// An optional listener that will receive all process events.
290 /// If \a listener is valid then \a listener will listen to all
291 /// process events. If not valid, then this target's debugger
292 /// (SBTarget::GetDebugger()) will listen to all process events.
295 /// The process ID to attach to.
298 /// An error explaining what went wrong if attach fails.
301 /// A process object for the attached process.
302 //------------------------------------------------------------------
303 ") AttachToProcessWithID;
305 AttachToProcessWithID (SBListener &listener,
307 lldb::SBError& error);
309 %feature("docstring", "
310 //------------------------------------------------------------------
311 /// Attach to process with name.
313 /// @param[in] listener
314 /// An optional listener that will receive all process events.
315 /// If \a listener is valid then \a listener will listen to all
316 /// process events. If not valid, then this target's debugger
317 /// (SBTarget::GetDebugger()) will listen to all process events.
320 /// Basename of process to attach to.
322 /// @param[in] wait_for
323 /// If true wait for a new instance of 'name' to be launched.
326 /// An error explaining what went wrong if attach fails.
329 /// A process object for the attached process.
330 //------------------------------------------------------------------
331 ") AttachToProcessWithName;
333 AttachToProcessWithName (SBListener &listener,
336 lldb::SBError& error);
338 %feature("docstring", "
339 //------------------------------------------------------------------
340 /// Connect to a remote debug server with url.
342 /// @param[in] listener
343 /// An optional listener that will receive all process events.
344 /// If \a listener is valid then \a listener will listen to all
345 /// process events. If not valid, then this target's debugger
346 /// (SBTarget::GetDebugger()) will listen to all process events.
349 /// The url to connect to, e.g., 'connect://localhost:12345'.
351 /// @param[in] plugin_name
352 /// The plugin name to be used; can be NULL.
355 /// An error explaining what went wrong if the connect fails.
358 /// A process object for the connected process.
359 //------------------------------------------------------------------
362 ConnectRemote (SBListener &listener,
364 const char *plugin_name,
371 AddModule (lldb::SBModule &module);
374 AddModule (const char *path,
379 AddModule (const char *path,
381 const char *uuid_cstr,
382 const char *symfile);
385 AddModule (const SBModuleSpec &module_spec);
388 GetNumModules () const;
391 GetModuleAtIndex (uint32_t idx);
394 RemoveModule (lldb::SBModule module);
400 FindModule (const lldb::SBFileSpec &file_spec);
406 GetAddressByteSize();
411 %feature("docstring", "
412 //------------------------------------------------------------------
413 /// Architecture data byte width accessor
416 /// The size in 8-bit (host) bytes of a minimum addressable
417 /// unit from the Architecture's data bus
418 //------------------------------------------------------------------
423 %feature("docstring", "
424 //------------------------------------------------------------------
425 /// Architecture code byte width accessor
428 /// The size in 8-bit (host) bytes of a minimum addressable
429 /// unit from the Architecture's code bus
430 //------------------------------------------------------------------
436 SetSectionLoadAddress (lldb::SBSection section,
437 lldb::addr_t section_base_addr);
440 ClearSectionLoadAddress (lldb::SBSection section);
443 SetModuleLoadAddress (lldb::SBModule module,
444 int64_t sections_offset);
447 ClearModuleLoadAddress (lldb::SBModule module);
449 %feature("docstring", "
450 //------------------------------------------------------------------
451 /// Find functions by name.
454 /// The name of the function we are looking for.
456 /// @param[in] name_type_mask
457 /// A logical OR of one or more FunctionNameType enum bits that
458 /// indicate what kind of names should be used when doing the
459 /// lookup. Bits include fully qualified names, base names,
460 /// C++ methods, or ObjC selectors.
461 /// See FunctionNameType for more details.
464 /// A lldb::SBSymbolContextList that gets filled in with all of
465 /// the symbol contexts for all the matches.
466 //------------------------------------------------------------------
468 lldb::SBSymbolContextList
469 FindFunctions (const char *name,
470 uint32_t name_type_mask = lldb::eFunctionNameTypeAny);
473 FindFirstType (const char* type);
476 FindTypes (const char* type);
479 GetBasicType(lldb::BasicType type);
481 lldb::SBSourceManager
484 %feature("docstring", "
485 //------------------------------------------------------------------
486 /// Find global and static variables by name.
489 /// The name of the global or static variable we are looking
492 /// @param[in] max_matches
493 /// Allow the number of matches to be limited to \a max_matches.
496 /// A list of matched variables in an SBValueList.
497 //------------------------------------------------------------------
498 ") FindGlobalVariables;
500 FindGlobalVariables (const char *name,
501 uint32_t max_matches);
503 %feature("docstring", "
504 //------------------------------------------------------------------
505 /// Find the first global (or static) variable by name.
508 /// The name of the global or static variable we are looking
512 /// An SBValue that gets filled in with the found variable (if any).
513 //------------------------------------------------------------------
514 ") FindFirstGlobalVariable;
516 FindFirstGlobalVariable (const char* name);
520 FindGlobalVariables(const char *name,
521 uint32_t max_matches,
522 MatchType matchtype);
524 lldb::SBSymbolContextList
525 FindGlobalFunctions(const char *name,
526 uint32_t max_matches,
527 MatchType matchtype);
532 %feature("docstring", "
533 //------------------------------------------------------------------
534 /// Resolve a current file address into a section offset address.
536 /// @param[in] file_addr
539 /// An SBAddress which will be valid if...
540 //------------------------------------------------------------------
541 ") ResolveFileAddress;
543 ResolveFileAddress (lldb::addr_t file_addr);
546 ResolveLoadAddress (lldb::addr_t vm_addr);
549 ResolvePastLoadAddress (uint32_t stop_id, lldb::addr_t vm_addr);
552 ResolveSymbolContextForAddress (const SBAddress& addr,
553 uint32_t resolve_scope);
555 %feature("docstring", "
556 //------------------------------------------------------------------
557 /// Read target memory. If a target process is running then memory
558 /// is read from here. Otherwise the memory is read from the object
559 /// files. For a target whose bytes are sized as a multiple of host
560 /// bytes, the data read back will preserve the target's byte order.
563 /// A target address to read from.
566 /// The buffer to read memory into.
569 /// The maximum number of host bytes to read in the buffer passed
572 /// @param[out] error
573 /// Error information is written here if the memory read fails.
576 /// The amount of data read in host bytes.
577 //------------------------------------------------------------------
580 ReadMemory (const SBAddress addr, void *buf, size_t size, lldb::SBError &error);
583 BreakpointCreateByLocation (const char *file, uint32_t line);
586 BreakpointCreateByLocation (const lldb::SBFileSpec &file_spec, uint32_t line);
589 BreakpointCreateByLocation (const lldb::SBFileSpec &file_spec, uint32_t line, lldb::addr_t offset);
592 BreakpointCreateByLocation (const lldb::SBFileSpec &file_spec, uint32_t line,
593 lldb::addr_t offset, SBFileSpecList &module_list);
596 BreakpointCreateByName (const char *symbol_name, const char *module_name = NULL);
599 BreakpointCreateByName (const char *symbol_name,
600 uint32_t func_name_type, // Logical OR one or more FunctionNameType enum bits
601 const SBFileSpecList &module_list,
602 const SBFileSpecList &comp_unit_list);
605 BreakpointCreateByName (const char *symbol_name,
606 uint32_t func_name_type, // Logical OR one or more FunctionNameType enum bits
607 lldb::LanguageType symbol_language,
608 const SBFileSpecList &module_list,
609 const SBFileSpecList &comp_unit_list);
611 %typemap(in) (const char **symbol_name, uint32_t num_names) {
612 using namespace lldb_private;
613 /* Check if is a list */
614 if (PythonList::Check($input)) {
615 PythonList list(PyRefType::Borrowed, $input);
618 $1 = (char**)malloc(($2+1)*sizeof(char*));
619 for (i = 0; i < $2; i++) {
620 PythonString py_str = list.GetItemAtIndex(i).AsType<PythonString>();
621 if (!py_str.IsAllocated()) {
622 PyErr_SetString(PyExc_TypeError,"list must contain strings and blubby");
627 $1[i] = const_cast<char*>(py_str.GetString().data());
630 } else if ($input == Py_None) {
633 PyErr_SetString(PyExc_TypeError,"not a list");
638 //%typecheck(SWIG_TYPECHECK_STRING_ARRAY) (const char *symbol_name[], uint32_t num_names) {
644 BreakpointCreateByNames (const char **symbol_name,
646 uint32_t name_type_mask, // Logical OR one or more FunctionNameType enum bits
647 const SBFileSpecList &module_list,
648 const SBFileSpecList &comp_unit_list);
651 BreakpointCreateByNames (const char **symbol_name,
653 uint32_t name_type_mask, // Logical OR one or more FunctionNameType enum bits
654 lldb::LanguageType symbol_language,
655 const SBFileSpecList &module_list,
656 const SBFileSpecList &comp_unit_list);
659 BreakpointCreateByNames (const char **symbol_name,
661 uint32_t name_type_mask, // Logical OR one or more FunctionNameType enum bits
662 lldb::LanguageType symbol_language,
664 const SBFileSpecList &module_list,
665 const SBFileSpecList &comp_unit_list);
668 BreakpointCreateByRegex (const char *symbol_name_regex, const char *module_name = NULL);
671 BreakpointCreateByRegex (const char *symbol_name_regex,
672 lldb::LanguageType symbol_language,
673 const SBFileSpecList &module_list,
674 const SBFileSpecList &comp_unit_list);
677 BreakpointCreateBySourceRegex (const char *source_regex, const lldb::SBFileSpec &source_file, const char *module_name = NULL);
680 BreakpointCreateBySourceRegex (const char *source_regex, const lldb::SBFileSpecList &module_list, const lldb::SBFileSpecList &file_list);
683 BreakpointCreateBySourceRegex (const char *source_regex,
684 const SBFileSpecList &module_list,
685 const SBFileSpecList &source_file,
686 const SBStringList &func_names);
689 BreakpointCreateForException (lldb::LanguageType language,
694 BreakpointCreateByAddress (addr_t address);
697 BreakpointCreateBySBAddress (SBAddress &sb_address);
700 GetNumBreakpoints () const;
703 GetBreakpointAtIndex (uint32_t idx) const;
706 BreakpointDelete (break_id_t break_id);
709 FindBreakpointByID (break_id_t break_id);
712 bool FindBreakpointsByName(const char *name, SBBreakpointList &bkpt_list);
715 EnableAllBreakpoints ();
718 DisableAllBreakpoints ();
721 DeleteAllBreakpoints ();
723 %feature("docstring", "
724 //------------------------------------------------------------------
725 /// Read breakpoints from source_file and return the newly created
726 /// breakpoints in bkpt_list.
728 /// @param[in] source_file
729 /// The file from which to read the breakpoints
731 /// @param[out] bkpt_list
732 /// A list of the newly created breakpoints.
735 /// An SBError detailing any errors in reading in the breakpoints.
736 //------------------------------------------------------------------
737 ") BreakpointsCreateFromFile;
739 BreakpointsCreateFromFile(SBFileSpec &source_file,
740 SBBreakpointList &bkpt_list);
742 %feature("docstring", "
743 //------------------------------------------------------------------
744 /// Read breakpoints from source_file and return the newly created
745 /// breakpoints in bkpt_list.
747 /// @param[in] source_file
748 /// The file from which to read the breakpoints
750 /// @param[in] matching_names
751 /// Only read in breakpoints whose names match one of the names in this
754 /// @param[out] bkpt_list
755 /// A list of the newly created breakpoints.
758 /// An SBError detailing any errors in reading in the breakpoints.
759 //------------------------------------------------------------------
760 ") BreakpointsCreateFromFile;
761 lldb::SBError BreakpointsCreateFromFile(SBFileSpec &source_file,
762 SBStringList &matching_names,
763 SBBreakpointList &new_bps);
765 %feature("docstring", "
766 //------------------------------------------------------------------
767 /// Write breakpoints to dest_file.
769 /// @param[in] dest_file
770 /// The file to which to write the breakpoints.
773 /// An SBError detailing any errors in writing in the breakpoints.
774 //------------------------------------------------------------------
775 ") BreakpointsCreateFromFile;
777 BreakpointsWriteToFile(SBFileSpec &dest_file);
779 %feature("docstring", "
780 //------------------------------------------------------------------
781 /// Write breakpoints listed in bkpt_list to dest_file.
783 /// @param[in] dest_file
784 /// The file to which to write the breakpoints.
786 /// @param[in] bkpt_list
787 /// Only write breakpoints from this list.
789 /// @param[in] append
790 /// If \btrue, append the breakpoints in bkpt_list to the others
791 /// serialized in dest_file. If dest_file doesn't exist, then a new
792 /// file will be created and the breakpoints in bkpt_list written to it.
795 /// An SBError detailing any errors in writing in the breakpoints.
796 //------------------------------------------------------------------
797 ") BreakpointsCreateFromFile;
799 BreakpointsWriteToFile(SBFileSpec &dest_file,
800 SBBreakpointList &bkpt_list,
801 bool append = false);
804 GetNumWatchpoints () const;
807 GetWatchpointAtIndex (uint32_t idx) const;
810 DeleteWatchpoint (lldb::watch_id_t watch_id);
813 FindWatchpointByID (lldb::watch_id_t watch_id);
816 EnableAllWatchpoints ();
819 DisableAllWatchpoints ();
822 DeleteAllWatchpoints ();
825 WatchAddress (lldb::addr_t addr,
833 GetBroadcaster () const;
835 %feature("docstring", "
836 //------------------------------------------------------------------
837 /// Create an SBValue with the given name by treating the memory starting at addr as an entity of type.
840 /// The name of the resultant SBValue
843 /// The address of the start of the memory region to be used.
846 /// The type to use to interpret the memory starting at addr.
849 /// An SBValue of the given type, may be invalid if there was an error reading
850 /// the underlying memory.
851 //------------------------------------------------------------------
852 ") CreateValueFromAddress;
854 CreateValueFromAddress (const char *name, lldb::SBAddress addr, lldb::SBType type);
857 CreateValueFromData (const char *name, lldb::SBData data, lldb::SBType type);
860 CreateValueFromExpression (const char *name, const char* expr);
862 %feature("docstring", "
863 Disassemble a specified number of instructions starting at an address.
865 base_addr -- the address to start disassembly from
866 count -- the number of instructions to disassemble
867 flavor_string -- may be 'intel' or 'att' on x86 targets to specify that style of disassembly
868 Returns an SBInstructionList.")
870 lldb::SBInstructionList
871 ReadInstructions (lldb::SBAddress base_addr, uint32_t count);
873 lldb::SBInstructionList
874 ReadInstructions (lldb::SBAddress base_addr, uint32_t count, const char *flavor_string);
876 %feature("docstring", "
877 Disassemble the bytes in a buffer and return them in an SBInstructionList.
879 base_addr -- used for symbolicating the offsets in the byte stream when disassembling
880 buf -- bytes to be disassembled
881 size -- (C++) size of the buffer
882 Returns an SBInstructionList.")
884 lldb::SBInstructionList
885 GetInstructions (lldb::SBAddress base_addr, const void *buf, size_t size);
887 %feature("docstring", "
888 Disassemble the bytes in a buffer and return them in an SBInstructionList, with a supplied flavor.
890 base_addr -- used for symbolicating the offsets in the byte stream when disassembling
891 flavor -- may be 'intel' or 'att' on x86 targets to specify that style of disassembly
892 buf -- bytes to be disassembled
893 size -- (C++) size of the buffer
894 Returns an SBInstructionList.")
895 GetInstructionsWithFlavor;
896 lldb::SBInstructionList
897 GetInstructionsWithFlavor (lldb::SBAddress base_addr, const char *flavor_string, const void *buf, size_t size);
899 lldb::SBSymbolContextList
900 FindSymbols (const char *name, lldb::SymbolType type = eSymbolTypeAny);
903 GetDescription (lldb::SBStream &description, lldb::DescriptionLevel description_level);
906 GetStackRedZoneSize();
909 GetLaunchInfo () const;
912 SetLaunchInfo (const lldb::SBLaunchInfo &launch_info);
915 operator == (const lldb::SBTarget &rhs) const;
918 operator != (const lldb::SBTarget &rhs) const;
921 EvaluateExpression (const char *expr);
924 EvaluateExpression (const char *expr, const lldb::SBExpressionOptions &options);
927 class modules_access(object):
928 '''A helper object that will lazily hand out lldb.SBModule objects for a target when supplied an index, or by full or partial path.'''
929 def __init__(self, sbtarget):
930 self.sbtarget = sbtarget
934 return int(self.sbtarget.GetNumModules())
937 def __getitem__(self, key):
938 num_modules = self.sbtarget.GetNumModules()
940 if key < num_modules:
941 return self.sbtarget.GetModuleAtIndex(key)
942 elif type(key) is str:
943 if key.find('/') == -1:
944 for idx in range(num_modules):
945 module = self.sbtarget.GetModuleAtIndex(idx)
946 if module.file.basename == key:
949 for idx in range(num_modules):
950 module = self.sbtarget.GetModuleAtIndex(idx)
951 if module.file.fullpath == key:
953 # See if the string is a UUID
955 the_uuid = uuid.UUID(key)
957 for idx in range(num_modules):
958 module = self.sbtarget.GetModuleAtIndex(idx)
959 if module.uuid == the_uuid:
963 elif type(key) is uuid.UUID:
964 for idx in range(num_modules):
965 module = self.sbtarget.GetModuleAtIndex(idx)
966 if module.uuid == key:
968 elif type(key) is re.SRE_Pattern:
969 matching_modules = []
970 for idx in range(num_modules):
971 module = self.sbtarget.GetModuleAtIndex(idx)
972 re_match = key.search(module.path.fullpath)
974 matching_modules.append(module)
975 return matching_modules
977 print("error: unsupported item type: %s" % type(key))
980 def get_modules_access_object(self):
981 '''An accessor function that returns a modules_access() object which allows lazy module access from a lldb.SBTarget object.'''
982 return self.modules_access (self)
984 def get_modules_array(self):
985 '''An accessor function that returns a list() that contains all modules in a lldb.SBTarget object.'''
987 for idx in range(self.GetNumModules()):
988 modules.append(self.GetModuleAtIndex(idx))
991 __swig_getmethods__["modules"] = get_modules_array
992 if _newclass: 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).''')
994 __swig_getmethods__["module"] = get_modules_access_object
995 if _newclass: 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.''')
997 __swig_getmethods__["process"] = GetProcess
998 if _newclass: process = property(GetProcess, None, doc='''A read only property that returns an lldb object that represents the process (lldb.SBProcess) that this target owns.''')
1000 __swig_getmethods__["executable"] = GetExecutable
1001 if _newclass: 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.''')
1003 __swig_getmethods__["debugger"] = GetDebugger
1004 if _newclass: debugger = property(GetDebugger, None, doc='''A read only property that returns an lldb object that represents the debugger (lldb.SBDebugger) that owns this target.''')
1006 __swig_getmethods__["num_breakpoints"] = GetNumBreakpoints
1007 if _newclass: num_breakpoints = property(GetNumBreakpoints, None, doc='''A read only property that returns the number of breakpoints that this target has as an integer.''')
1009 __swig_getmethods__["num_watchpoints"] = GetNumWatchpoints
1010 if _newclass: num_watchpoints = property(GetNumWatchpoints, None, doc='''A read only property that returns the number of watchpoints that this target has as an integer.''')
1012 __swig_getmethods__["broadcaster"] = GetBroadcaster
1013 if _newclass: broadcaster = property(GetBroadcaster, None, doc='''A read only property that an lldb object that represents the broadcaster (lldb.SBBroadcaster) for this target.''')
1015 __swig_getmethods__["byte_order"] = GetByteOrder
1016 if _newclass: 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.''')
1018 __swig_getmethods__["addr_size"] = GetAddressByteSize
1019 if _newclass: addr_size = property(GetAddressByteSize, None, doc='''A read only property that returns the size in bytes of an address for this target.''')
1021 __swig_getmethods__["triple"] = GetTriple
1022 if _newclass: triple = property(GetTriple, None, doc='''A read only property that returns the target triple (arch-vendor-os) for this target as a string.''')
1024 __swig_getmethods__["data_byte_size"] = GetDataByteSize
1025 if _newclass: 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.''')
1027 __swig_getmethods__["code_byte_size"] = GetCodeByteSize
1028 if _newclass: 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.''')
1030 __swig_getmethods__["platform"] = GetPlatform
1031 if _newclass: platform = property(GetPlatform, None, doc='''A read only property that returns the platform associated with with this target.''')