662548c826
Instead of maintaining separate swig interface files, we can use the API headers directly. They implement the exact same C++ APIs and we can conditionally include the python extensions as needed. To remove the swig extensions from the API headers when building the LLDB framework, we can use the unifdef tool when it is available. Otherwise we just copy them as-is. Differential Revision: https://reviews.llvm.org/D142926
235 lines
12 KiB
OpenEdge ABL
235 lines
12 KiB
OpenEdge ABL
#ifdef SWIGPYTHON
|
|
%pythoncode%{
|
|
# ==================================
|
|
# Helper function for SBModule class
|
|
# ==================================
|
|
def in_range(symbol, section):
|
|
"""Test whether a symbol is within the range of a section."""
|
|
symSA = symbol.GetStartAddress().GetFileAddress()
|
|
symEA = symbol.GetEndAddress().GetFileAddress()
|
|
secSA = section.GetFileAddress()
|
|
secEA = secSA + section.GetByteSize()
|
|
|
|
if symEA != LLDB_INVALID_ADDRESS:
|
|
if secSA <= symSA and symEA <= secEA:
|
|
return True
|
|
else:
|
|
return False
|
|
else:
|
|
if secSA <= symSA and symSA < secEA:
|
|
return True
|
|
else:
|
|
return False
|
|
%}
|
|
#endif
|
|
|
|
STRING_EXTENSION_OUTSIDE(SBModule)
|
|
|
|
%extend lldb::SBModule {
|
|
#ifdef SWIGPYTHON
|
|
%pythoncode %{
|
|
def __len__(self):
|
|
'''Return the number of symbols in a lldb.SBModule object.'''
|
|
return self.GetNumSymbols()
|
|
|
|
def __iter__(self):
|
|
'''Iterate over all symbols in a lldb.SBModule object.'''
|
|
return lldb_iter(self, 'GetNumSymbols', 'GetSymbolAtIndex')
|
|
|
|
def section_iter(self):
|
|
'''Iterate over all sections in a lldb.SBModule object.'''
|
|
return lldb_iter(self, 'GetNumSections', 'GetSectionAtIndex')
|
|
|
|
def compile_unit_iter(self):
|
|
'''Iterate over all compile units in a lldb.SBModule object.'''
|
|
return lldb_iter(self, 'GetNumCompileUnits', 'GetCompileUnitAtIndex')
|
|
|
|
def symbol_in_section_iter(self, section):
|
|
'''Given a module and its contained section, returns an iterator on the
|
|
symbols within the section.'''
|
|
for sym in self:
|
|
if in_range(sym, section):
|
|
yield sym
|
|
|
|
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 -count <= key < count:
|
|
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 -count <= key < count:
|
|
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 -count <= key < count:
|
|
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
|
|
|
|
symbols = property(get_symbols_array, None, doc='''A read only property that returns a list() of lldb.SBSymbol objects contained in this module.''')
|
|
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''')
|
|
sections = property(get_sections_array, None, doc='''A read only property that returns a list() of lldb.SBSection objects contained in this module.''')
|
|
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.''')
|
|
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''')
|
|
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())
|
|
|
|
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.''')
|
|
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.''')
|
|
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.''')
|
|
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.''')
|
|
addr_size = property(GetAddressByteSize, None, doc='''A read only property that returns the size in bytes of an address for this module.''')
|
|
triple = property(GetTriple, None, doc='''A read only property that returns the target triple (arch-vendor-os) for this module.''')
|
|
num_symbols = property(GetNumSymbols, None, doc='''A read only property that returns number of symbols in the module symbol table as an integer.''')
|
|
num_sections = property(GetNumSections, None, doc='''A read only property that returns number of sections in the module as an integer.''')
|
|
|
|
%}
|
|
#endif
|
|
}
|