diff options
Diffstat (limited to 'lldb/scripts/Python/interface/SBModule.i')
| -rw-r--r-- | lldb/scripts/Python/interface/SBModule.i | 400 |
1 files changed, 0 insertions, 400 deletions
diff --git a/lldb/scripts/Python/interface/SBModule.i b/lldb/scripts/Python/interface/SBModule.i deleted file mode 100644 index 1b6d4ecac432..000000000000 --- a/lldb/scripts/Python/interface/SBModule.i +++ /dev/null @@ -1,400 +0,0 @@ -//===-- SWIG Interface for SBModule -----------------------------*- 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 an executable image and its associated object and symbol files. - -The module is designed to be able to select a single slice of an -executable image as it would appear on disk and during program -execution. - -You can retrieve SBModule from SBSymbolContext, which in turn is available -from SBFrame. - -SBModule supports symbol iteration, for example, - - for symbol in module: - name = symbol.GetName() - saddr = symbol.GetStartAddress() - eaddr = symbol.GetEndAddress() - -and rich comparion methods which allow the API program to use, - - if thisModule == thatModule: - print 'This module is the same as that module' - -to test module equality. A module also contains object file sections, namely -SBSection. SBModule supports section iteration through section_iter(), for -example, - - print 'Number of sections: %d' % module.GetNumSections() - for sec in module.section_iter(): - print sec - -And to iterate the symbols within a SBSection, use symbol_in_section_iter(), - - # Iterates the text section and prints each symbols within each sub-section. - for subsec in text_sec: - print INDENT + repr(subsec) - for sym in exe_module.symbol_in_section_iter(subsec): - print INDENT2 + repr(sym) - print INDENT2 + 'symbol type: %s' % symbol_type_to_str(sym.GetType()) - -produces this following output: - - [0x0000000100001780-0x0000000100001d5c) a.out.__TEXT.__text - id = {0x00000004}, name = 'mask_access(MaskAction, unsigned int)', range = [0x00000001000017c0-0x0000000100001870) - symbol type: code - id = {0x00000008}, name = 'thread_func(void*)', range = [0x0000000100001870-0x00000001000019b0) - symbol type: code - id = {0x0000000c}, name = 'main', range = [0x00000001000019b0-0x0000000100001d5c) - symbol type: code - id = {0x00000023}, name = 'start', address = 0x0000000100001780 - symbol type: code - [0x0000000100001d5c-0x0000000100001da4) a.out.__TEXT.__stubs - id = {0x00000024}, name = '__stack_chk_fail', range = [0x0000000100001d5c-0x0000000100001d62) - symbol type: trampoline - id = {0x00000028}, name = 'exit', range = [0x0000000100001d62-0x0000000100001d68) - symbol type: trampoline - id = {0x00000029}, name = 'fflush', range = [0x0000000100001d68-0x0000000100001d6e) - symbol type: trampoline - id = {0x0000002a}, name = 'fgets', range = [0x0000000100001d6e-0x0000000100001d74) - symbol type: trampoline - id = {0x0000002b}, name = 'printf', range = [0x0000000100001d74-0x0000000100001d7a) - symbol type: trampoline - id = {0x0000002c}, name = 'pthread_create', range = [0x0000000100001d7a-0x0000000100001d80) - symbol type: trampoline - id = {0x0000002d}, name = 'pthread_join', range = [0x0000000100001d80-0x0000000100001d86) - symbol type: trampoline - id = {0x0000002e}, name = 'pthread_mutex_lock', range = [0x0000000100001d86-0x0000000100001d8c) - symbol type: trampoline - id = {0x0000002f}, name = 'pthread_mutex_unlock', range = [0x0000000100001d8c-0x0000000100001d92) - symbol type: trampoline - id = {0x00000030}, name = 'rand', range = [0x0000000100001d92-0x0000000100001d98) - symbol type: trampoline - id = {0x00000031}, name = 'strtoul', range = [0x0000000100001d98-0x0000000100001d9e) - symbol type: trampoline - id = {0x00000032}, name = 'usleep', range = [0x0000000100001d9e-0x0000000100001da4) - symbol type: trampoline - [0x0000000100001da4-0x0000000100001e2c) a.out.__TEXT.__stub_helper - [0x0000000100001e2c-0x0000000100001f10) a.out.__TEXT.__cstring - [0x0000000100001f10-0x0000000100001f68) a.out.__TEXT.__unwind_info - [0x0000000100001f68-0x0000000100001ff8) a.out.__TEXT.__eh_frame -" -) SBModule; -class SBModule -{ -public: - - SBModule (); - - SBModule (const SBModule &rhs); - - SBModule (lldb::SBProcess &process, - lldb::addr_t header_addr); - - ~SBModule (); - - bool - IsValid () const; - - void - Clear(); - - %feature("docstring", " - //------------------------------------------------------------------ - /// Get const accessor for the module file specification. - /// - /// This function returns the file for the module on the host system - /// that is running LLDB. This can differ from the path on the - /// platform since we might be doing remote debugging. - /// - /// @return - /// A const reference to the file specification object. - //------------------------------------------------------------------ - ") GetFileSpec; - lldb::SBFileSpec - GetFileSpec () const; - - %feature("docstring", " - //------------------------------------------------------------------ - /// Get accessor for the module platform file specification. - /// - /// Platform file refers to the path of the module as it is known on - /// the remote system on which it is being debugged. For local - /// debugging this is always the same as Module::GetFileSpec(). But - /// remote debugging might mention a file '/usr/lib/liba.dylib' - /// which might be locally downloaded and cached. In this case the - /// platform file could be something like: - /// '/tmp/lldb/platform-cache/remote.host.computer/usr/lib/liba.dylib' - /// The file could also be cached in a local developer kit directory. - /// - /// @return - /// A const reference to the file specification object. - //------------------------------------------------------------------ - ") GetPlatformFileSpec; - lldb::SBFileSpec - GetPlatformFileSpec () const; - - bool - SetPlatformFileSpec (const lldb::SBFileSpec &platform_file); - - %feature("docstring", "Returns the UUID of the module as a Python string." - ) GetUUIDString; - const char * - GetUUIDString () const; - - lldb::SBSection - FindSection (const char *sect_name); - - lldb::SBAddress - ResolveFileAddress (lldb::addr_t vm_addr); - - lldb::SBSymbolContext - ResolveSymbolContextForAddress (const lldb::SBAddress& addr, - uint32_t resolve_scope); - - bool - GetDescription (lldb::SBStream &description); - - uint32_t - GetNumCompileUnits(); - - lldb::SBCompileUnit - GetCompileUnitAtIndex (uint32_t); - - size_t - GetNumSymbols (); - - lldb::SBSymbol - GetSymbolAtIndex (size_t idx); - - size_t - GetNumSections (); - - lldb::SBSection - GetSectionAtIndex (size_t idx); - - - %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 symbol context list that gets filled in with all of the - /// matches. - //------------------------------------------------------------------ - ") FindFunctions; - lldb::SBSymbolContextList - FindFunctions (const char *name, - uint32_t name_type_mask = lldb::eFunctionNameTypeAny); - - lldb::SBType - FindFirstType (const char* name); - - lldb::SBTypeList - FindTypes (const char* type); - - - %feature("docstring", " - //------------------------------------------------------------------ - /// Find global and static variables by name. - /// - /// @param[in] target - /// A valid SBTarget instance representing the debuggee. - /// - /// @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 (lldb::SBTarget &target, - const char *name, - uint32_t max_matches); - - lldb::ByteOrder - GetByteOrder (); - - uint32_t - GetAddressByteSize(); - - const char * - GetTriple (); - - uint32_t - GetVersion (uint32_t *versions, - uint32_t num_versions); - - %pythoncode %{ - class symbols_access(object): - re_compile_type = type(re.compile('.')) - '''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, sbmodule): - self.sbmodule = sbmodule - - def __len__(self): - if self.sbmodule: - return self.sbmodule.GetNumSymbols() - return 0 - - def __getitem__(self, key): - count = len(self) - if type(key) is int: - if key < count: - return self.sbmodule.GetSymbolAtIndex(key) - elif type(key) is str: - matches = [] - for idx in range(count): - symbol = self.sbmodule.GetSymbolAtIndex(idx) - if symbol.name == key or symbol.mangled == key: - matches.append(symbol) - return matches - elif isinstance(key, self.re_compile_type): - matches = [] - for idx in range(count): - symbol = self.sbmodule.GetSymbolAtIndex(idx) - added = False - name = symbol.name - if name: - re_match = key.search(name) - if re_match: - matches.append(symbol) - added = True - if not added: - mangled = symbol.mangled - if mangled: - re_match = key.search(mangled) - if re_match: - matches.append(symbol) - return matches - else: - print "error: unsupported item type: %s" % type(key) - return None - - def get_symbols_access_object(self): - '''An accessor function that returns a symbols_access() object which allows lazy symbol access from a lldb.SBModule object.''' - return self.symbols_access (self) - - def get_symbols_array(self): - '''An accessor function that returns a list() that contains all symbols in a lldb.SBModule object.''' - symbols = [] - for idx in range(self.num_symbols): - symbols.append(self.GetSymbolAtIndex(idx)) - return symbols - - class sections_access(object): - re_compile_type = type(re.compile('.')) - '''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, sbmodule): - self.sbmodule = sbmodule - - def __len__(self): - if self.sbmodule: - return self.sbmodule.GetNumSections() - return 0 - - def __getitem__(self, key): - count = len(self) - if type(key) is int: - if key < count: - return self.sbmodule.GetSectionAtIndex(key) - elif type(key) is str: - for idx in range(count): - section = self.sbmodule.GetSectionAtIndex(idx) - if section.name == key: - return section - elif isinstance(key, self.re_compile_type): - matches = [] - for idx in range(count): - section = self.sbmodule.GetSectionAtIndex(idx) - name = section.name - if name: - re_match = key.search(name) - if re_match: - matches.append(section) - return matches - else: - print "error: unsupported item type: %s" % type(key) - return None - - def get_sections_access_object(self): - '''An accessor function that returns a sections_access() object which allows lazy section array access.''' - return self.sections_access (self) - - def get_sections_array(self): - '''An accessor function that returns an array object that contains all sections in this module object.''' - if not hasattr(self, 'sections'): - self.sections = [] - for idx in range(self.num_sections): - self.sections.append(self.GetSectionAtIndex(idx)) - return self.sections - - __swig_getmethods__["symbols"] = get_symbols_array - if _newclass: x = property(get_symbols_array, None) - - __swig_getmethods__["symbol"] = get_symbols_access_object - if _newclass: x = property(get_symbols_access_object, None) - - __swig_getmethods__["sections"] = get_sections_array - if _newclass: x = property(get_sections_array, None) - - __swig_getmethods__["section"] = get_sections_access_object - if _newclass: x = property(get_sections_access_object, None) - - def get_uuid(self): - return uuid.UUID (self.GetUUIDString()) - - __swig_getmethods__["uuid"] = get_uuid - if _newclass: x = property(get_uuid, None) - - __swig_getmethods__["file"] = GetFileSpec - if _newclass: x = property(GetFileSpec, None) - - __swig_getmethods__["platform_file"] = GetPlatformFileSpec - if _newclass: x = property(GetPlatformFileSpec, None) - - __swig_getmethods__["byte_order"] = GetByteOrder - if _newclass: x = property(GetByteOrder, None) - - __swig_getmethods__["addr_size"] = GetAddressByteSize - if _newclass: x = property(GetAddressByteSize, None) - - __swig_getmethods__["triple"] = GetTriple - if _newclass: x = property(GetTriple, None) - - __swig_getmethods__["num_symbols"] = GetNumSymbols - if _newclass: x = property(GetNumSymbols, None) - - __swig_getmethods__["num_sections"] = GetNumSections - if _newclass: x = property(GetNumSections, None) - - %} - -}; - -} // namespace lldb |