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

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 == int(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(),

int(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, (PyKeysValuesPair, PyDictObjectPtr)):

out.write('(')

first = True

items = pyop_attrdict.iteritems()

for pyop_arg, pyop_val in items:

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.items()])

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:

if int_from_int(typeobj.field('tp_flags')) & Py_TPFLAGS_MANAGED_DICT:

assert dictoffset == -1

dictoffset = -3 * _sizeof_void_p()

else:

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 % _sizeof_void_p() == 0

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

PyObjectPtrPtr = PyObjectPtr.get_gdb_type().pointer()

dictptr = dictptr.cast(PyObjectPtrPtr)

if int(dictptr.dereference()) & 1:

return None

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 get_keys_values(self):

typeobj = self.type()

has_values = int_from_int(typeobj.field('tp_flags')) & Py_TPFLAGS_MANAGED_DICT

if not has_values:

return None

charptrptr_t = _type_char_ptr().pointer()

ptr = self._gdbval.cast(charptrptr_t) - 3

char_ptr = ptr.dereference()

if (int(char_ptr) & 1) == 0:

return None

char_ptr += 1

values_ptr = char_ptr.cast(gdb.lookup_type("PyDictValues").pointer())

values = values_ptr['values']

return PyKeysValuesPair(self.get_cached_keys(), values)

def get_cached_keys(self):

typeobj = self.type()

HeapTypePtr = gdb.lookup_type("PyHeapTypeObject").pointer()

return typeobj._gdbval.cast(HeapTypePtr)['ht_cached_keys']

def proxyval(self, visited):

'''

# Guard against infinite loops:

if self.as_address() in visited:

return ProxyAlreadyVisited('<...>')

visited.add(self.as_address())

keys_values = self.get_keys_values()

if keys_values:

attr_dict = keys_values.proxyval(visited)

else:

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, int(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_attrs = self.get_keys_values()

if not pyop_attrs:

pyop_attrs = 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:

b = read(it)

val = b & 63;

shift = 0;

while b & 64:

b = read(it)

shift += 6

val |= (b&63) << shift

uval = read_varint(it)

if uval & 1:

return -(uval >> 1)

else:

line = firstlineno

addr = 0

it = iter(linetable)

while True:

try:

first_byte = read(it)

except StopIteration:

return

code = (first_byte >> 3) & 15

length = (first_byte & 7) + 1

end_addr = addr + length

if code == 15:

yield addr, end_addr, None

addr = end_addr

continue

elif code == 14: # Long form

line_delta = read_signed_varint(it)

line += line_delta

end_line = line + read_varint(it)

col = read_varint(it)

end_col = read_varint(it)

elif code == 13: # No column

line_delta = read_signed_varint(it)

line += line_delta

elif code in (10, 11, 12): # new line

line_delta = code - 10

line += line_delta

column = read(it)

end_column = read(it)

else:

assert (0 <= code < 10)

second_byte = read(it)

column = code << 3 | (second_byte >> 4)

yield addr, end_addr, line

"""

_typename = 'PyCodeObject'

def addr2line(self, addrq):

'''

co_linetable = self.pyop_field('co_linetable').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'))

if addrq < 0:

return lineno

addr = 0

for addr, end_addr, line in parse_location_table(lineno, co_linetable):

if addr <= addrq and end_addr > addrq:

return line

entries, nentries = PyDictObjectPtr._get_entries(keys)

for i in safe_range(nentries):

ep = entries[i]

pyop_value = PyObjectPtr.from_pyobject_ptr(values[i])

if not pyop_value.is_null():

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

def __init__(self, keys, values):

self.keys = keys

self.values = values

def iteritems(self):

return items_from_keys_and_values(self.keys, self.values)

def proxyval(self, visited):

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

"""

_typename = 'PyDictObject'

def iteritems(self):

'''

keys = self.field('ma_keys')

values = self.field('ma_values')

has_values = int(values)

if has_values:

values = values['values']

if has_values:

for item in items_from_keys_and_values(keys, values):

yield item

return

entries, nentries = self._get_entries(keys)

for i in safe_range(nentries):

ep = entries[i]

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

@staticmethod

def _get_entries(keys):

dk_nentries = int(keys['dk_nentries'])

dk_size = 1<<int(keys['dk_log2_size'])

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

if int(keys['dk_kind']) == 0: # DICT_KEYS_GENERAL

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

else:

ent_ptr_t = gdb.lookup_type('PyDictUnicodeEntry').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 = int(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 = [int(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._frame = PyFramePtr(self.field('f_frame'))

def iter_locals(self):

'''

if self.is_optimized_out():

return

return self._frame.iter_locals()

def iter_globals(self):

'''

if self.is_optimized_out():

return ()

return self._frame.iter_globals()

def iter_builtins(self):

'''

if self.is_optimized_out():

return ()

return self._frame.iter_builtins()

def get_var_by_name(self, name):

if self.is_optimized_out():

return None, None

return self._frame.get_var_by_name(name)

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._frame.filename()

def current_line_num(self):

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

if self.is_optimized_out():

return None

return self._frame.current_line_num()