forked from OSchip/llvm-project
531 lines
23 KiB
C++
531 lines
23 KiB
C++
//===-- 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 comparison 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 lldb::SBModule &rhs);
|
|
|
|
SBModule (const lldb::SBModuleSpec &module_spec);
|
|
|
|
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);
|
|
|
|
lldb::SBFileSpec
|
|
GetRemoteInstallFileSpec ();
|
|
|
|
bool
|
|
SetRemoteInstallFileSpec (lldb::SBFileSpec &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);
|
|
|
|
lldb::SBSymbol
|
|
FindSymbol (const char *name,
|
|
lldb::SymbolType type = eSymbolTypeAny);
|
|
|
|
lldb::SBSymbolContextList
|
|
FindSymbols (const char *name,
|
|
lldb::SymbolType type = eSymbolTypeAny);
|
|
|
|
|
|
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);
|
|
|
|
lldb::SBType
|
|
GetTypeByID (lldb::user_id_t uid);
|
|
|
|
lldb::SBType
|
|
GetBasicType(lldb::BasicType type);
|
|
|
|
%feature("docstring", "
|
|
//------------------------------------------------------------------
|
|
/// Get all types matching \a type_mask from debug info in this
|
|
/// module.
|
|
///
|
|
/// @param[in] type_mask
|
|
/// A bitfield that consists of one or more bits logically OR'ed
|
|
/// together from the lldb::TypeClass enumeration. This allows
|
|
/// you to request only structure types, or only class, struct
|
|
/// and union types. Passing in lldb::eTypeClassAny will return
|
|
/// all types found in the debug information for this module.
|
|
///
|
|
/// @return
|
|
/// A list of types in this module that match \a type_mask
|
|
//------------------------------------------------------------------
|
|
") GetTypes;
|
|
lldb::SBTypeList
|
|
GetTypes (uint32_t type_mask = lldb::eTypeClassAny);
|
|
|
|
%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);
|
|
|
|
%feature("docstring", "
|
|
//------------------------------------------------------------------
|
|
/// Find the first global (or static) variable 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.
|
|
///
|
|
/// @return
|
|
/// An SBValue that gets filled in with the found variable (if any).
|
|
//------------------------------------------------------------------
|
|
") FindFirstGlobalVariable;
|
|
lldb::SBValue
|
|
FindFirstGlobalVariable (lldb::SBTarget &target, const char *name);
|
|
|
|
lldb::ByteOrder
|
|
GetByteOrder ();
|
|
|
|
uint32_t
|
|
GetAddressByteSize();
|
|
|
|
const char *
|
|
GetTriple ();
|
|
|
|
uint32_t
|
|
GetVersion (uint32_t *versions,
|
|
uint32_t num_versions);
|
|
|
|
lldb::SBFileSpec
|
|
GetSymbolFileSpec() const;
|
|
|
|
lldb::SBAddress
|
|
GetObjectFileHeaderAddress() const;
|
|
|
|
bool
|
|
operator == (const lldb::SBModule &rhs) const;
|
|
|
|
bool
|
|
operator != (const lldb::SBModule &rhs) const;
|
|
|
|
%pythoncode %{
|
|
class symbols_access(object):
|
|
re_compile_type = type(re.compile('.'))
|
|
'''A helper object that will lazily hand out lldb.SBSymbol objects for a module when supplied an index, name, or regular expression.'''
|
|
def __init__(self, sbmodule):
|
|
self.sbmodule = sbmodule
|
|
|
|
def __len__(self):
|
|
if self.sbmodule:
|
|
return int(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 = []
|
|
sc_list = self.sbmodule.FindSymbols(key)
|
|
for sc in sc_list:
|
|
symbol = sc.symbol
|
|
if symbol:
|
|
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_compile_units_access_object (self):
|
|
'''An accessor function that returns a compile_units_access() object which allows lazy compile unit access from a lldb.SBModule object.'''
|
|
return self.compile_units_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.SBSection objects for a module when supplied an index, name, or regular expression.'''
|
|
def __init__(self, sbmodule):
|
|
self.sbmodule = sbmodule
|
|
|
|
def __len__(self):
|
|
if self.sbmodule:
|
|
return int(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
|
|
|
|
class compile_units_access(object):
|
|
re_compile_type = type(re.compile('.'))
|
|
'''A helper object that will lazily hand out lldb.SBCompileUnit objects for a module when supplied an index, full or partial path, or regular expression.'''
|
|
def __init__(self, sbmodule):
|
|
self.sbmodule = sbmodule
|
|
|
|
def __len__(self):
|
|
if self.sbmodule:
|
|
return int(self.sbmodule.GetNumCompileUnits())
|
|
return 0
|
|
|
|
def __getitem__(self, key):
|
|
count = len(self)
|
|
if type(key) is int:
|
|
if key < count:
|
|
return self.sbmodule.GetCompileUnitAtIndex(key)
|
|
elif type(key) is str:
|
|
is_full_path = key[0] == '/'
|
|
for idx in range(count):
|
|
comp_unit = self.sbmodule.GetCompileUnitAtIndex(idx)
|
|
if is_full_path:
|
|
if comp_unit.file.fullpath == key:
|
|
return comp_unit
|
|
else:
|
|
if comp_unit.file.basename == key:
|
|
return comp_unit
|
|
elif isinstance(key, self.re_compile_type):
|
|
matches = []
|
|
for idx in range(count):
|
|
comp_unit = self.sbmodule.GetCompileUnitAtIndex(idx)
|
|
fullpath = comp_unit.file.fullpath
|
|
if fullpath:
|
|
re_match = key.search(fullpath)
|
|
if re_match:
|
|
matches.append(comp_unit)
|
|
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_array'):
|
|
self.sections_array = []
|
|
for idx in range(self.num_sections):
|
|
self.sections_array.append(self.GetSectionAtIndex(idx))
|
|
return self.sections_array
|
|
|
|
def get_compile_units_array(self):
|
|
'''An accessor function that returns an array object that contains all compile_units in this module object.'''
|
|
if not hasattr(self, 'compile_units_array'):
|
|
self.compile_units_array = []
|
|
for idx in range(self.GetNumCompileUnits()):
|
|
self.compile_units_array.append(self.GetCompileUnitAtIndex(idx))
|
|
return self.compile_units_array
|
|
|
|
__swig_getmethods__["symbols"] = get_symbols_array
|
|
if _newclass: symbols = property(get_symbols_array, None, doc='''A read only property that returns a list() of lldb.SBSymbol objects contained in this module.''')
|
|
|
|
__swig_getmethods__["symbol"] = get_symbols_access_object
|
|
if _newclass: symbol = property(get_symbols_access_object, None, doc='''A read only property that can be used to access symbols by index ("symbol = module.symbol[0]"), name ("symbols = module.symbol['main']"), or using a regular expression ("symbols = module.symbol[re.compile(...)]"). The return value is a single lldb.SBSymbol object for array access, and a list() of lldb.SBSymbol objects for name and regular expression access''')
|
|
|
|
__swig_getmethods__["sections"] = get_sections_array
|
|
if _newclass: sections = property(get_sections_array, None, doc='''A read only property that returns a list() of lldb.SBSection objects contained in this module.''')
|
|
|
|
__swig_getmethods__["compile_units"] = get_compile_units_array
|
|
if _newclass: compile_units = property(get_compile_units_array, None, doc='''A read only property that returns a list() of lldb.SBCompileUnit objects contained in this module.''')
|
|
|
|
__swig_getmethods__["section"] = get_sections_access_object
|
|
if _newclass: section = property(get_sections_access_object, None, doc='''A read only property that can be used to access symbols by index ("section = module.section[0]"), name ("sections = module.section[\'main\']"), or using a regular expression ("sections = module.section[re.compile(...)]"). The return value is a single lldb.SBSection object for array access, and a list() of lldb.SBSection objects for name and regular expression access''')
|
|
|
|
__swig_getmethods__["compile_unit"] = get_compile_units_access_object
|
|
if _newclass: section = property(get_sections_access_object, None, doc='''A read only property that can be used to access compile units by index ("compile_unit = module.compile_unit[0]"), name ("compile_unit = module.compile_unit[\'main.cpp\']"), or using a regular expression ("compile_unit = module.compile_unit[re.compile(...)]"). The return value is a single lldb.SBCompileUnit object for array access or by full or partial path, and a list() of lldb.SBCompileUnit objects regular expressions.''')
|
|
|
|
def get_uuid(self):
|
|
return uuid.UUID (self.GetUUIDString())
|
|
|
|
__swig_getmethods__["uuid"] = get_uuid
|
|
if _newclass: uuid = property(get_uuid, None, doc='''A read only property that returns a standard python uuid.UUID object that represents the UUID of this module.''')
|
|
|
|
__swig_getmethods__["file"] = GetFileSpec
|
|
if _newclass: file = property(GetFileSpec, None, doc='''A read only property that returns an lldb object that represents the file (lldb.SBFileSpec) for this object file for this module as it is represented where it is being debugged.''')
|
|
|
|
__swig_getmethods__["platform_file"] = GetPlatformFileSpec
|
|
if _newclass: platform_file = property(GetPlatformFileSpec, None, doc='''A read only property that returns an lldb object that represents the file (lldb.SBFileSpec) for this object file for this module as it is represented on the current host system.''')
|
|
|
|
__swig_getmethods__["byte_order"] = GetByteOrder
|
|
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 module.''')
|
|
|
|
__swig_getmethods__["addr_size"] = GetAddressByteSize
|
|
if _newclass: addr_size = property(GetAddressByteSize, None, doc='''A read only property that returns the size in bytes of an address for this module.''')
|
|
|
|
__swig_getmethods__["triple"] = GetTriple
|
|
if _newclass: triple = property(GetTriple, None, doc='''A read only property that returns the target triple (arch-vendor-os) for this module.''')
|
|
|
|
__swig_getmethods__["num_symbols"] = GetNumSymbols
|
|
if _newclass: num_symbols = property(GetNumSymbols, None, doc='''A read only property that returns number of symbols in the module symbol table as an integer.''')
|
|
|
|
__swig_getmethods__["num_sections"] = GetNumSections
|
|
if _newclass: num_sections = property(GetNumSections, None, doc='''A read only property that returns number of sections in the module as an integer.''')
|
|
|
|
%}
|
|
|
|
};
|
|
|
|
} // namespace lldb
|