# Given a 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:

return self.type().field('tp_name').string()

except NullPyObjectPtr:

# NULL tp_name?

return 'unknown'

except RuntimeError:

# Can't even read the object at all?

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'))

except RuntimeError:

# 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,

}

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*)

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

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')

for i in safe_range(keys['dk_size']):

ep = keys['dk_entries'].address + 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)

_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 information 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

else:

#try:

return self.co.addr2line(self.f_lasti)

#except ValueError:

# return self.f_lineno

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 information optimized out)'

filename = self.filename()

try:

f = open(os_fsencode(filename), 'r')

except IOError:

return None

with f:

all_lines = f.readlines()

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

return all_lines[self.current_line_num()-1]

def write_repr(self, out, visited):

if self.is_optimized_out():

out.write('(frame information optimized out)')

return

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

% (self.as_address(),

self.co_filename.proxyval(visited),

self.current_line_num(),

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(' (frame information optimized out)\n')

return

visited = set()

sys.stdout.write(' File "%s", line %i, in %s\n'

% (self.co_filename.proxyval(visited),

self.current_line_num(),

_typename = 'PySetObject'

def proxyval(self, visited):

# Guard against infinite loops:

if self.as_address() in visited:

return ProxyAlreadyVisited('%s(...)' % self.safe_tp_name())

visited.add(self.as_address())

members = []

table = self.field('table')

for i in safe_range(self.field('mask')+1):

setentry = table[i]

key = setentry['key']

if key != 0:

key_proxy = PyObjectPtr.from_pyobject_ptr(key).proxyval(visited)

if key_proxy != '<dummy key>':

members.append(key_proxy)

if self.safe_tp_name() == 'frozenset':

return frozenset(members)

else:

return set(members)

def write_repr(self, out, visited):

# Emulate Python 3's set_repr

tp_name = self.safe_tp_name()

# Guard against infinite loops:

if self.as_address() in visited:

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

return

visited.add(self.as_address())

# Python 3's set_repr special-cases the empty set:

if not self.field('used'):

out.write(tp_name)

out.write('()')

return

# Python 3 uses {} for set literals:

if tp_name != 'set':

out.write(tp_name)

out.write('(')

out.write('{')

first = True

table = self.field('table')

for i in safe_range(self.field('mask')+1):

setentry = table[i]

key = setentry['key']

if key != 0:

pyop_key = PyObjectPtr.from_pyobject_ptr(key)

key_proxy = pyop_key.proxyval(visited) # FIXME!

if key_proxy != '<dummy key>':

if not first:

out.write(', ')

first = False

pyop_key.write_repr(out, visited)

out.write('}')

if tp_name != 'set':