# Given an integer value from the process being debugged, limit it to some

# safety threshold so that arbitrary breakage within said process doesn't

# break the gdb process too much (e.g. sizes of iterations, sizes of lists)

# Write a byte or unicode string to file. Unicode strings are encoded to

# ENCODING encoding with 'backslashreplace' error handler to avoid

# UnicodeEncodeError.

if isinstance(text, unicode):

text = text.encode(ENCODING, 'backslashreplace')

if not isinstance(filename, unicode):

return filename

encoding = sys.getfilesystemencoding()

if encoding == 'mbcs':

# mbcs doesn't support surrogateescape

return filename.encode(encoding)

encoded = []

for char in filename:

# surrogateescape error handler

if 0xDC80 <= ord(char) <= 0xDCFF:

byte = chr(ord(char) - 0xDC00)

else:

byte = char.encode(encoding)

encoded.append(byte)

'''Similar to io.StringIO, but can truncate the output by raising a

def __init__(self, maxlen=None):

self._val = ''

self.maxlen = maxlen

def write(self, data):

if self.maxlen:

if len(data) + len(self._val) > self.maxlen:

# Truncation:

self._val += data[0:self.maxlen - len(self._val)]

raise StringTruncated()

self._val += data

def getvalue(self):

"""

_typename = 'PyObject'

def __init__(self, gdbval, cast_to=None):

if cast_to:

self._gdbval = gdbval.cast(cast_to)

else:

self._gdbval = gdbval

def field(self, name):

'''

if self.is_null():

raise NullPyObjectPtr(self)

if name == 'ob_type':

pyo_ptr = self._gdbval.cast(PyObjectPtr.get_gdb_type())

return pyo_ptr.dereference()[name]

if name == 'ob_size':

pyo_ptr = self._gdbval.cast(PyVarObjectPtr.get_gdb_type())

return pyo_ptr.dereference()[name]

# General case: look it up inside the object:

return self._gdbval.dereference()[name]

def pyop_field(self, name):

'''

return PyObjectPtr.from_pyobject_ptr(self.field(name))

def write_field_repr(self, name, out, visited):

'''

field_obj = self.pyop_field(name)

field_obj.write_repr(out, visited)

def get_truncated_repr(self, maxlen):

'''

out = TruncatedStringIO(maxlen)

try:

self.write_repr(out, set())

except StringTruncated:

# Truncation occurred:

return out.getvalue() + '...(truncated)'

# No truncation occurred:

return out.getvalue()

def type(self):

return PyTypeObjectPtr(self.field('ob_type'))

def is_null(self):

return 0 == long(self._gdbval)

def is_optimized_out(self):

'''

return self._gdbval.is_optimized_out

def safe_tp_name(self):

try:

ob_type = self.type()

tp_name = ob_type.field('tp_name')

return tp_name.string()

# NullPyObjectPtr: NULL tp_name?

# RuntimeError: Can't even read the object at all?

# UnicodeDecodeError: Failed to decode tp_name bytestring

except (NullPyObjectPtr, RuntimeError, UnicodeDecodeError):

return 'unknown'

def proxyval(self, visited):

'''

class FakeRepr(object):

"""

def __init__(self, tp_name, address):

self.tp_name = tp_name

self.address = address

def __repr__(self):

# For the NULL pointer, we have no way of knowing a type, so

# special-case it as per

# http://bugs.python.org/issue8032#msg100882

if self.address == 0:

return '0x0'

return '<%s at remote 0x%x>' % (self.tp_name, self.address)

return FakeRepr(self.safe_tp_name(),

long(self._gdbval))

def write_repr(self, out, visited):

'''

# Default implementation: generate a proxy value and write its repr

# However, this could involve a lot of work for complicated objects,

# so for derived classes we specialize this

return out.write(repr(self.proxyval(visited)))

@classmethod

def subclass_from_type(cls, t):

'''

try:

tp_name = t.field('tp_name').string()

tp_flags = int(t.field('tp_flags'))

# RuntimeError: NULL pointers

# UnicodeDecodeError: string() fails to decode the bytestring

except (RuntimeError, UnicodeDecodeError):

# Handle any kind of error e.g. NULL ptrs by simply using the base

# class

return cls

#print('tp_flags = 0x%08x' % tp_flags)

#print('tp_name = %r' % tp_name)

name_map = {'bool': PyBoolObjectPtr,

'classobj': PyClassObjectPtr,

'NoneType': PyNoneStructPtr,

'frame': PyFrameObjectPtr,

'set' : PySetObjectPtr,

'frozenset' : PySetObjectPtr,

'builtin_function_or_method' : PyCFunctionObjectPtr,

'method-wrapper': wrapperobject,

}

if tp_name in name_map:

return name_map[tp_name]

if tp_flags & Py_TPFLAGS_HEAPTYPE:

return HeapTypeObjectPtr

if tp_flags & Py_TPFLAGS_LONG_SUBCLASS:

return PyLongObjectPtr

if tp_flags & Py_TPFLAGS_LIST_SUBCLASS:

return PyListObjectPtr

if tp_flags & Py_TPFLAGS_TUPLE_SUBCLASS:

return PyTupleObjectPtr

if tp_flags & Py_TPFLAGS_BYTES_SUBCLASS:

return PyBytesObjectPtr

if tp_flags & Py_TPFLAGS_UNICODE_SUBCLASS:

return PyUnicodeObjectPtr

if tp_flags & Py_TPFLAGS_DICT_SUBCLASS:

return PyDictObjectPtr

if tp_flags & Py_TPFLAGS_BASE_EXC_SUBCLASS:

return PyBaseExceptionObjectPtr

#if tp_flags & Py_TPFLAGS_TYPE_SUBCLASS:

# return PyTypeObjectPtr

# Use the base class:

return cls

@classmethod

def from_pyobject_ptr(cls, gdbval):

'''

try:

p = PyObjectPtr(gdbval)

cls = cls.subclass_from_type(p.type())

return cls(gdbval, cast_to=cls.get_gdb_type())

except RuntimeError:

# Handle any kind of error e.g. NULL ptrs by simply using the base

# class

pass

return cls(gdbval)

@classmethod

def get_gdb_type(cls):

return gdb.lookup_type(cls._typename).pointer()

def as_address(self):

'''

def __init__(self, rep):

self._rep = rep

def __repr__(self):

'''Shared code for use by all classes:

out.write('<')

out.write(name)

# Write dictionary of instance attributes:

if isinstance(pyop_attrdict, PyDictObjectPtr):

out.write('(')

first = True

for pyop_arg, pyop_val in pyop_attrdict.iteritems():

if not first:

out.write(', ')

first = False

out.write(pyop_arg.proxyval(visited))

out.write('=')

pyop_val.write_repr(out, visited)

out.write(')')

def __init__(self, cl_name, attrdict, address):

self.cl_name = cl_name

self.attrdict = attrdict

self.address = address

def __repr__(self):

if isinstance(self.attrdict, dict):

kwargs = ', '.join(["%s=%r" % (arg, val)

for arg, val in self.attrdict.iteritems()])

return '<%s(%s) at remote 0x%x>' % (self.cl_name,

kwargs, self.address)

else:

return '<%s at remote 0x%x>' % (self.cl_name,

if _PyObject_VAR_SIZE._type_size_t is None:

_PyObject_VAR_SIZE._type_size_t = gdb.lookup_type('size_t')

return ( ( typeobj.field('tp_basicsize') +

nitems * typeobj.field('tp_itemsize') +

(_sizeof_void_p() - 1)

) & ~(_sizeof_void_p() - 1)

_typename = 'PyObject'

def get_attr_dict(self):

'''

try:

typeobj = self.type()

dictoffset = int_from_int(typeobj.field('tp_dictoffset'))

if dictoffset != 0:

if dictoffset < 0:

type_PyVarObject_ptr = gdb.lookup_type('PyVarObject').pointer()

tsize = int_from_int(self._gdbval.cast(type_PyVarObject_ptr)['ob_size'])

if tsize < 0:

tsize = -tsize

size = _PyObject_VAR_SIZE(typeobj, tsize)

dictoffset += size

assert dictoffset > 0

assert dictoffset % _sizeof_void_p() == 0

dictptr = self._gdbval.cast(_type_char_ptr()) + dictoffset

PyObjectPtrPtr = PyObjectPtr.get_gdb_type().pointer()

dictptr = dictptr.cast(PyObjectPtrPtr)

return PyObjectPtr.from_pyobject_ptr(dictptr.dereference())

except RuntimeError:

# Corrupt data somewhere; fail safe

pass

# Not found, or some kind of error:

return None

def proxyval(self, visited):

'''

# Guard against infinite loops:

if self.as_address() in visited:

return ProxyAlreadyVisited('<...>')

visited.add(self.as_address())

pyop_attr_dict = self.get_attr_dict()

if pyop_attr_dict:

attr_dict = pyop_attr_dict.proxyval(visited)

else:

attr_dict = {}

tp_name = self.safe_tp_name()

# Class:

return InstanceProxy(tp_name, attr_dict, long(self._gdbval))

def write_repr(self, out, visited):

# Guard against infinite loops:

if self.as_address() in visited:

out.write('<...>')

return

visited.add(self.as_address())

pyop_attrdict = self.get_attr_dict()

_write_instance_repr(out, visited,

def __init__(self, tp_name, args):

self.tp_name = tp_name

self.args = args

def __repr__(self):

"""

_typename = 'PyBaseExceptionObject'

def proxyval(self, visited):

# Guard against infinite loops:

if self.as_address() in visited:

return ProxyAlreadyVisited('(...)')

visited.add(self.as_address())

arg_proxy = self.pyop_field('args').proxyval(visited)

return ProxyException(self.safe_tp_name(),

arg_proxy)

def write_repr(self, out, visited):

# Guard against infinite loops:

if self.as_address() in visited:

out.write('(...)')

return

visited.add(self.as_address())

out.write(self.safe_tp_name())

"""

def __init__(self, ml_name):

self.ml_name = ml_name

def __repr__(self):

def __init__(self, ml_name, pyop_m_self):

self.ml_name = ml_name

self.pyop_m_self = pyop_m_self

def __repr__(self):

return ('<built-in method %s of %s object at remote 0x%x>'

% (self.ml_name,

self.pyop_m_self.safe_tp_name(),

self.pyop_m_self.as_address())

"""

_typename = 'PyCFunctionObject'

def proxyval(self, visited):

m_ml = self.field('m_ml') # m_ml is a (PyMethodDef*)

try:

ml_name = m_ml['ml_name'].string()

except UnicodeDecodeError:

ml_name = '<ml_name:UnicodeDecodeError>'

pyop_m_self = self.pyop_field('m_self')

if pyop_m_self.is_null():

return BuiltInFunctionProxy(ml_name)

else:

"""

_typename = 'PyCodeObject'

def addr2line(self, addrq):

'''

co_lnotab = self.pyop_field('co_lnotab').proxyval(set())

# Initialize lineno to co_firstlineno as per PyCode_Addr2Line

# not 0, as lnotab_notes.txt has it:

lineno = int_from_int(self.field('co_firstlineno'))

addr = 0

for addr_incr, line_incr in zip(co_lnotab[::2], co_lnotab[1::2]):

addr += ord(addr_incr)

if addr > addrq:

return lineno

lineno += ord(line_incr)

"""

_typename = 'PyDictObject'

def iteritems(self):

'''

keys = self.field('ma_keys')

values = self.field('ma_values')

entries, nentries = self._get_entries(keys)

for i in safe_range(nentries):

ep = entries[i]

if long(values):

pyop_value = PyObjectPtr.from_pyobject_ptr(values[i])

else:

pyop_value = PyObjectPtr.from_pyobject_ptr(ep['me_value'])

if not pyop_value.is_null():

pyop_key = PyObjectPtr.from_pyobject_ptr(ep['me_key'])

yield (pyop_key, pyop_value)

def proxyval(self, visited):

# Guard against infinite loops:

if self.as_address() in visited:

return ProxyAlreadyVisited('{...}')

visited.add(self.as_address())

result = {}

for pyop_key, pyop_value in self.iteritems():

proxy_key = pyop_key.proxyval(visited)

proxy_value = pyop_value.proxyval(visited)

result[proxy_key] = proxy_value

return result

def write_repr(self, out, visited):

# Guard against infinite loops:

if self.as_address() in visited:

out.write('{...}')

return

visited.add(self.as_address())

out.write('{')

first = True

for pyop_key, pyop_value in self.iteritems():

if not first:

out.write(', ')

first = False

pyop_key.write_repr(out, visited)

out.write(': ')

pyop_value.write_repr(out, visited)

out.write('}')

def _get_entries(self, keys):

dk_nentries = int(keys['dk_nentries'])

dk_size = int(keys['dk_size'])

try:

# <= Python 3.5

return keys['dk_entries'], dk_size

except RuntimeError:

# >= Python 3.6

pass

if dk_size <= 0xFF:

offset = dk_size

elif dk_size <= 0xFFFF:

offset = 2 * dk_size

elif dk_size <= 0xFFFFFFFF:

offset = 4 * dk_size

else:

offset = 8 * dk_size

ent_addr = keys['dk_indices'].address

ent_addr = ent_addr.cast(_type_unsigned_char_ptr()) + offset

ent_ptr_t = gdb.lookup_type('PyDictKeyEntry').pointer()

ent_addr = ent_addr.cast(ent_ptr_t)

_typename = 'PyListObject'

def __getitem__(self, i):

# Get the gdb.Value for the (PyObject*) with the given index:

field_ob_item = self.field('ob_item')

return field_ob_item[i]

def proxyval(self, visited):

# Guard against infinite loops:

if self.as_address() in visited:

return ProxyAlreadyVisited('[...]')

visited.add(self.as_address())

result = [PyObjectPtr.from_pyobject_ptr(self[i]).proxyval(visited)

for i in safe_range(int_from_int(self.field('ob_size')))]

return result

def write_repr(self, out, visited):

# Guard against infinite loops:

if self.as_address() in visited:

out.write('[...]')

return

visited.add(self.as_address())

out.write('[')

for i in safe_range(int_from_int(self.field('ob_size'))):

if i > 0:

out.write(', ')

element = PyObjectPtr.from_pyobject_ptr(self[i])

element.write_repr(out, visited)

_typename = 'PyLongObject'

def proxyval(self, visited):

'''

ob_size = long(self.field('ob_size'))

if ob_size == 0:

return 0

ob_digit = self.field('ob_digit')

if gdb.lookup_type('digit').sizeof == 2:

SHIFT = 15

else:

SHIFT = 30

digits = [long(ob_digit[i]) * 2**(SHIFT*i)

for i in safe_range(abs(ob_size))]

result = sum(digits)

if ob_size < 0:

result = -result

return result

def write_repr(self, out, visited):

# Write this out as a Python 3 int literal, i.e. without the "L" suffix

proxy = self.proxyval(visited)

"""

def proxyval(self, visited):

if PyLongObjectPtr.proxyval(self, visited):

return True

else:

"""

_typename = 'PyObject'

def proxyval(self, visited):

_typename = 'PyFrameObject'

def __init__(self, gdbval, cast_to=None):

PyObjectPtr.__init__(self, gdbval, cast_to)

if not self.is_optimized_out():

self.co = PyCodeObjectPtr.from_pyobject_ptr(self.field('f_code'))

self.co_name = self.co.pyop_field('co_name')

self.co_filename = self.co.pyop_field('co_filename')

self.f_lineno = int_from_int(self.field('f_lineno'))

self.f_lasti = int_from_int(self.field('f_lasti'))

self.co_nlocals = int_from_int(self.co.field('co_nlocals'))

self.co_varnames = PyTupleObjectPtr.from_pyobject_ptr(self.co.field('co_varnames'))

def iter_locals(self):

'''

if self.is_optimized_out():

return

f_localsplus = self.field('f_localsplus')

for i in safe_range(self.co_nlocals):

pyop_value = PyObjectPtr.from_pyobject_ptr(f_localsplus[i])

if not pyop_value.is_null():

pyop_name = PyObjectPtr.from_pyobject_ptr(self.co_varnames[i])

yield (pyop_name, pyop_value)

def iter_globals(self):

'''

if self.is_optimized_out():

return ()

pyop_globals = self.pyop_field('f_globals')

return pyop_globals.iteritems()

def iter_builtins(self):

'''

if self.is_optimized_out():

return ()

pyop_builtins = self.pyop_field('f_builtins')

return pyop_builtins.iteritems()

def get_var_by_name(self, name):

'''

for pyop_name, pyop_value in self.iter_locals():

if name == pyop_name.proxyval(set()):

return pyop_value, 'local'

for pyop_name, pyop_value in self.iter_globals():

if name == pyop_name.proxyval(set()):

return pyop_value, 'global'

for pyop_name, pyop_value in self.iter_builtins():

if name == pyop_name.proxyval(set()):

return pyop_value, 'builtin'

return None, None

def filename(self):

'''Get the path of the current Python source file, as a string'''

if self.is_optimized_out():

return FRAME_INFO_OPTIMIZED_OUT

return self.co_filename.proxyval(set())

def current_line_num(self):

'''Get current line number as an integer (1-based)

if self.is_optimized_out():

return None

f_trace = self.field('f_trace')

if long(f_trace) != 0:

# we have a non-NULL f_trace:

return self.f_lineno

try:

return self.co.addr2line(self.f_lasti)

except Exception:

# bpo-34989: addr2line() is a complex function, it can fail in many

# ways. For example, it fails with a TypeError on "FakeRepr" if

# gdb fails to load debug symbols. Use a catch-all "except

# Exception" to make the whole function safe. The caller has to

# handle None anyway for optimized Python.

return None

def current_line(self):

'''Get the text of the current source line as a string, with a trailing

if self.is_optimized_out():

return FRAME_INFO_OPTIMIZED_OUT

lineno = self.current_line_num()

if lineno is None:

return '(failed to get frame line number)'

filename = self.filename()

try:

with open(os_fsencode(filename), 'r') as fp:

lines = fp.readlines()

except IOError:

return None

try:

# Convert from 1-based current_line_num to 0-based list offset

return lines[lineno - 1]

except IndexError:

return None

def write_repr(self, out, visited):

if self.is_optimized_out():

out.write(FRAME_INFO_OPTIMIZED_OUT)

return

lineno = self.current_line_num()

lineno = str(lineno) if lineno is not None else "?"

out.write('Frame 0x%x, for file %s, line %s, in %s ('

% (self.as_address(),

self.co_filename.proxyval(visited),

lineno,

self.co_name.proxyval(visited)))

first = True

for pyop_name, pyop_value in self.iter_locals():

if not first:

out.write(', ')

first = False

out.write(pyop_name.proxyval(visited))

out.write('=')

pyop_value.write_repr(out, visited)

out.write(')')

def print_traceback(self):

if self.is_optimized_out():

sys.stdout.write(' %s\n' % FRAME_INFO_OPTIMIZED_OUT)

return

visited = set()