def to_string(self):
if self.VectorOfPitEntries == None:
xVector = gdb.xmethods[gdb.xmethod._lookup_xmethod_matcher(gdb, 'libstdc++::vector')]._method_dict['size'].worker_class
self.VectorOfPitEntries = xVector(gdb.lookup_type("std::shared_ptr<nfd::pit::Entry>"))
self.VectorOfNameTreeEntries = xVector(gdb.lookup_type("std::shared_ptr<nfd::name_tree::Entry>"))
name = self.val['m_prefix']['m_nameBlock']
nameValue = name['m_buffer']['_M_ptr'].dereference()['_M_impl']['_M_start']
nameMem = gdb.selected_inferior().read_memory(nameValue, name['m_size'])
name = pyndn.Name()
name.wireDecode(pyndn.Blob.fromRawStr(nameMem))
fib = self.val['m_fibEntry']['_M_ptr']
p = self.val['m_pitEntries']
m = self.val['m_measurementsEntry']['_M_ptr']
s = self.val['m_strategyChoiceEntry']['_M_ptr']
parent = self.val['m_parent']['_M_ptr']
children = self.val['m_children']
return '{"nFIB": %d, "nPIT": %d, "nMsmnts": %d, "nSC": %d, "nParent": %d, "nChildren": %d, "Prefix": "%s"},' % (fib != 0, self.VectorOfPitEntries.size(p), m != 0, s != 0,
parent != 0, self.VectorOfNameTreeEntries.size(children),
name.toUri())
def __init__(self, val):
SwigIterator.__init__(self);
try:
self.valid = False
self.val = val.reinterpret_cast(self.t_doh_base_ptr)
self.t_struct_hash_ptr = gdb.lookup_type("struct Hash").pointer()
self.t_struct_hash_node_ptr = gdb.lookup_type("struct HashNode").pointer()
doh_base = self.val.dereference()
hash_ = doh_base['data'].reinterpret_cast(self.t_struct_hash_ptr).dereference()
self.hashtable = hash_['hashtable']
self.hashsize = int(hash_['hashsize'])
self.nitems = int(hash_['nitems'])
self.next_ = 0
self.address = 0
self.pos = 0;
self._current = 0
self.item = 0
self.key = 0
self._index = 0
self.address = self.val.dereference().address
self.is_first = True
self.valid = True
except Exception as err:
print_("SwigHashIterator: Construction failed.\n %s.\n"%(str(err)))
def find_thread(thread_id):
thread_p = gdb.lookup_type('osRtxThread_t').pointer()
thread = thread_id.cast(thread_p)
u32_t = gdb.lookup_type("uint32_t")
stack = thread['sp'].cast(u32_t.pointer())
return (stack[0xE], stack + 0x8)
def invoke(self, arg, from_tty):
ptr = int(arg, 0)
owning_thread = None
for t, start, size in seastar_memory_layout():
if ptr >= start and ptr < start + size:
owning_thread = t
break
if not owning_thread:
gdb.write("Not managed by seastar\n")
return
msg = "thread %d" % t.num
owning_thread.switch()
cpu_mem = gdb.parse_and_eval("'memory::cpu_mem'")
page_size = int(gdb.parse_and_eval("'memory::page_size'"))
offset = ptr - int(cpu_mem["memory"])
page = cpu_mem["pages"][offset / page_size]
if page["free"]:
msg += ", page is free"
gdb.write(msg + "\n")
return
pool = page["pool"]
offset_in_span = page["offset_in_span"] * page_size + ptr % page_size
first_page_in_span = cpu_mem["pages"][offset / page_size - page["offset_in_span"]]
if pool:
object_size = int(pool["_object_size"])
msg += ", small (size <= %d)" % object_size
offset_in_object = offset_in_span % object_size
free_object_ptr = gdb.lookup_type("void").pointer().pointer()
char_ptr = gdb.lookup_type("char").pointer()
# pool's free list
next_free = pool["_free"]
free = False
while next_free:
if ptr >= next_free and ptr < next_free.reinterpret_cast(char_ptr) + object_size:
free = True
break
next_free = next_free.reinterpret_cast(free_object_ptr).dereference()
if not free:
# span's free list
next_free = first_page_in_span["freelist"]
while next_free:
if ptr >= next_free and ptr < next_free.reinterpret_cast(char_ptr) + object_size:
free = True
break
next_free = next_free.reinterpret_cast(free_object_ptr).dereference()
if free:
msg += ", free"
else:
msg += ", live (0x%x +%d)" % (ptr - offset_in_object, offset_in_object)
else:
msg += ", large"
gdb.write(msg + "\n")
return
def query(type):
if type.code == gdb.TYPE_CODE_REF:
type = type.target()
type = type.unqualified().strip_typedefs()
if not type.tag:
return False
ushort = gdb.lookup_type('sal_uInt16')
conforming = True
for field in type.fields():
if field.name == 'pData':
conforming = field.type.code == gdb.TYPE_CODE_PTR
elif field.name == 'nFree':
conforming = field.type == ushort
elif field.name == 'nA':
conforming = field.type == ushort
else:
conforming = False
if not conforming:
return False
try:
gdb.lookup_type('FnForEach_' + type.tag)
except RuntimeError:
return False
return True
def invoke(self, arg, from_tty):
element_type = gdb.lookup_type('WebCore::Element')
node_type = gdb.lookup_type('WebCore::Node')
frame = gdb.selected_frame()
try:
val = gdb.Frame.read_var(frame, arg)
except:
print "No such variable, or invalid type"
return
target_type = str(val.type.target().strip_typedefs())
if target_type == str(node_type):
stack = []
while val:
stack.append([val,
val.cast(element_type.pointer()).dereference()['m_tagName']])
val = val.dereference()['m_parent']
padding = ''
while len(stack) > 0:
pair = stack.pop()
print padding, pair[1], pair[0]
padding = padding + ' '
else:
print 'Sorry: I don\'t know how to deal with %s yet.' % target_type
def children(self):
# Only support kPackedKind or kMixedKind
if self.kind == self.packedKind() or self.kind == self.mixedKind():
data = self.val.address.cast(gdb.lookup_type("char").pointer()) + self.val.type.sizeof
pelm = data.cast(gdb.lookup_type("HPHP::HphpArray::Elm").pointer())
return self._iterator(self.kind, pelm, pelm + self.val["m_size"])
return self._iterator(0, 0, 0)
def _print_enum(self, val, vtype, tname):
'''HACK Given an explicitly enumerated type, try and match the current value
to one of the enumerated values. This is really all about nsresult and the
rules about enums and the underlying representing types. gdb is totally able to
understand that a 0 nsresult is `nsresult::NS_OK`, but it breaks as soon as the
high order bit is flipped because it ends up seeing the underlying int type as
int32_t but the constant is uint32_t.
Even if the necessity of this check is addressed, it might make sense to keep a
first-class understanding of enums so we can pretty print the namespaces.
'''
# TODO: nsresult really demands caching...
# Because of enum rules about the representation type perhaps not
# being reflected into gdb or whatever, we end up seeing nsresult as a
# signed int32_t, so let's just cast over to unsigned before extracting
# out instead of doing bit twiddling.
try:
tsize = vtype.sizeof
if tsize <= 4:
val = val.cast(gdb.lookup_type('uint32_t'))
else:
val = val.cast(gdb.lookup_type('uint64_t'))
num_val = val + 0
except:
# maybe we don't have those typedefs? bollocks. whatever.
pass
for field in vtype.fields():
#pout('{s}checking %s %x', field.name, field.enumval)
if field.enumval == num_val:
# XXX use a logger that maybe prints the namespace as {s}
pout('{n}%s', field.name)
return
pout('{s}unknown enum value {n}%x', num_val)
def __init__(self, val, cls, begin, end):
self.cur = begin
self.end = end
if self.cur != self.end:
addr = val.address.cast(gdb.lookup_type("char").pointer())
addr = addr + val.type.sizeof + cls["m_builtinODTailSize"]
self.addr = addr.cast(gdb.lookup_type("HPHP::TypedValue").pointer())
def match(self, class_type, method_name):
class_tag = class_type.unqualified().tag
if not re.match('^dop::G<[ ]*[_a-zA-Z][ _a-zA-Z0-9]*>$',
class_tag):
return None
t_name = class_tag[7:-1]
try:
t_type = gdb.lookup_type(t_name)
except gdb.error:
return None
if re.match('^size_diff<[ ]*[_a-zA-Z][ _a-zA-Z0-9]*>$', method_name):
if not self._is_enabled('size_diff'):
return None
t1_name = method_name[10:-1]
try:
t1_type = gdb.lookup_type(t1_name)
return G_size_diff_worker(t_type, t1_type)
except gdb.error:
return None
if re.match('^size_mul<[ ]*[0-9]+[ ]*>$', method_name):
if not self._is_enabled('size_mul'):
return None
m_val = int(method_name[9:-1])
return G_size_mul_worker(t_type, m_val)
if re.match('^mul<[ ]*[_a-zA-Z][ _a-zA-Z0-9]*>$', method_name):
if not self._is_enabled('mul'):
return None
t1_name = method_name[4:-1]
try:
t1_type = gdb.lookup_type(t1_name)
return G_mul_worker(t_type, t1_type)
except gdb.error:
return None
def next(self):
if self.count >= self.d['end'] - self.d['begin']:
raise StopIteration
count = self.count
array = self.d['array'][self.d['begin'] + count]
#from QTypeInfo::isLarge
isLarge = self.nodetype.sizeof > gdb.lookup_type('void').pointer().sizeof
#isStatic is not needed anymore since Qt 4.6
#isPointer = self.nodetype.code == gdb.TYPE_CODE_PTR
#
##unfortunately we can't use QTypeInfo<T>::isStatic as it's all inlined, so use
##this list of types that use Q_DECLARE_TYPEINFO(T, Q_MOVABLE_TYPE)
##(obviously it won't work for custom types)
#movableTypes = ['QRect', 'QRectF', 'QString', 'QMargins', 'QLocale', 'QChar', 'QDate', 'QTime', 'QDateTime', 'QVector',
# 'QRegExpr', 'QPoint', 'QPointF', 'QByteArray', 'QSize', 'QSizeF', 'QBitArray', 'QLine', 'QLineF', 'QModelIndex', 'QPersitentModelIndex',
# 'QVariant', 'QFileInfo', 'QUrl', 'QXmlStreamAttribute', 'QXmlStreamNamespaceDeclaration', 'QXmlStreamNotationDeclaration',
# 'QXmlStreamEntityDeclaration']
#if movableTypes.count(self.nodetype.tag):
# isStatic = False
#else:
# isStatic = not isPointer
isStatic = False
if isLarge or isStatic: #see QList::Node::t()
node = array.cast(gdb.lookup_type('QList<%s>::Node' % self.nodetype).pointer())
else:
node = array.cast(gdb.lookup_type('QList<%s>::Node' % self.nodetype))
self.count = self.count + 1
return ('[%d]' % count, node['v'].cast(self.nodetype))
def children(self):
all_fibers = \
self.fm['allFibers_']['data_']['root_plus_size_']['m_header']
fiber_hook = all_fibers['next_']
active_fibers = collections.OrderedDict()
fiber_count = 0
while fiber_hook != all_fibers.address:
if fiber_count == FiberManagerPrinter.fiber_print_limit:
active_fibers["..."] = "..."
break
fiber = fiber_hook.cast(gdb.lookup_type("int64_t"))
fiber = fiber - gdb.parse_and_eval(
"(int64_t)&folly::fibers::Fiber::globalListHook_")
fiber = fiber.cast(
gdb.lookup_type('folly::fibers::Fiber').pointer()).dereference()
if FiberPrinter(fiber).state != "folly::fibers::Fiber::INVALID":
active_fibers[str(fiber.address)] = fiber
fiber_hook = fiber_hook.dereference()['next_']
fiber_count = fiber_count + 1
return active_fibers.items()
def execute(self, argv):
super_blocks = gdb.lookup_symbol('super_blocks', None)[0].value()
sbtype = gdb.lookup_type('struct super_block')
try:
btrfs_fs_info_type = gdb.lookup_type('struct btrfs_fs_info')
except gdb.error:
# Load the module if it's not loaded yet
module_type = gdb.lookup_type('struct module')
modules = gdb.lookup_symbol('modules', None)[0].value()
for module in list_for_each_entry(modules, module_type, 'list'):
if module['name'].string() == "btrfs":
addr = module['module_core']
gdb.execute("add-symbol-file {} {}".format(path, addr))
btrfs_fs_info_type = gdb.lookup_type('struct btrfs_fs_info')
for sb in list_for_each_entry(super_blocks, sbtype, 's_list'):
if sb['s_type']['name'].string() == "btrfs":
fs_info = gdb.Value(sb['s_fs_info']).cast(btrfs_fs_info_type.pointer())
u = long(0)
for i in range(0, 16):
u <<= 8
u += int(fs_info['fsid'][i])
u = uuid.UUID(int=u)
print "{} -> {} {}".format(sb.address, sb['s_id'].string(), u)
def invoke(self, _args, from_tty):
args = gdb.string_to_argv(_args)
start_node = args[0]
if len(args) > 1:
max_iter = int(args[1])
else:
max_iter = self.MAX_ITER
if len(args) > 2:
lvl = int(args[2])
else:
lvl = 0
p_node_t = gdb.lookup_type('node_t').pointer()
long_t = gdb.lookup_type('long')
node = gdb.parse_and_eval(start_node)
print node
for i in xrange(max_iter):
nexts = node['next']
nxt = gdb.Value(nexts[lvl]).cast(long_t)
nxt = nxt & ~1
node = gdb.Value(nxt).cast(p_node_t).dereference()
nexts = node['next']
print node['k'], node['level'], node['inserting'],
k = 0
while k < node['level']:
print(nexts[k]),
k+=1
print("")
def to_string(self):
chars_start = self.val.address + 1
if self.is_8bit():
return lstring_to_string(chars_start.cast(gdb.lookup_type('char').pointer()),
self.get_length())
return ustring_to_string(chars_start.cast(gdb.lookup_type('UChar').pointer()),
self.get_length())
def __call__(self, pending_frame):
if self.recurse_level > 0:
gdb.write("TestUnwinder: Recursion detected - returning early.\n")
return None
self.recurse_level += 1
TestUnwinder.inc_count()
if TestUnwinder.test == 'check_user_reg_pc' :
pc = pending_frame.read_register('pc')
pc_as_int = int(pc.cast(gdb.lookup_type('int')))
# gdb.write("In unwinder: pc=%x\n" % pc_as_int)
elif TestUnwinder.test == 'check_pae_pc' :
pc = gdb.parse_and_eval('$pc')
pc_as_int = int(pc.cast(gdb.lookup_type('int')))
# gdb.write("In unwinder: pc=%x\n" % pc_as_int)
elif TestUnwinder.test == 'check_undefined_symbol' :
try:
val = gdb.parse_and_eval("undefined_symbol")
except Exception as arg:
pass
self.recurse_level -= 1
return None
def __init__(self, val, cls, begin, end):
self.cur = begin
self.end = end
if self.cur != self.end:
addr = val.address.cast(gdb.lookup_type('char').pointer())
addr = addr + val.type.sizeof + cls['m_builtinPropSize']
self.addr = addr.cast(gdb.lookup_type('HPHP::TypedValue').pointer())
def payload (self):
if gdb.parse_and_eval:
ret = int(gdb.parse_and_eval('QMap<%s, %s>::payload()' % (self.ktype, self.vtype)))
if (ret): return ret;
#if the inferior function call didn't work, let's try to calculate ourselves
#we can't use QMapPayloadNode as it's inlined
#as a workaround take the sum of sizeof(members)
ret = self.ktype.sizeof
ret += self.vtype.sizeof
ret += gdb.lookup_type('void').pointer().sizeof
#but because of data alignment the value can be higher
#so guess it's aliged by sizeof(void*)
#TODO: find a real solution for this problem
ret += ret % gdb.lookup_type('void').pointer().sizeof
#for some reason booleans are different
if str(self.vtype) == 'bool':
ret += 2
ret -= gdb.lookup_type('void').pointer().sizeof
return ret
def __next__(self):
if self.count >= self.d['end'] - self.d['begin']:
raise StopIteration
count = self.count
array = self.d['array'][self.d['begin'] + count]
#from QTypeInfo::isLarge
isLarge = self.nodetype.sizeof > gdb.lookup_type('void').pointer().sizeof
isPointer = self.nodetype.code == gdb.TYPE_CODE_PTR
#unfortunately we can't use QTypeInfo<T>::isStatic as it's all inlined, so use
#this list of types that use Q_DECLARE_TYPEINFO(T, Q_MOVABLE_TYPE)
#(obviously it won't work for custom types)
movableTypes = ['QRect', 'QRectF', 'QString', 'QMargins', 'QLocale', 'QChar', 'QDate', 'QTime', 'QDateTime', 'QVector',
'QRegExpr', 'QPoint', 'QPointF', 'QByteArray', 'QSize', 'QSizeF', 'QBitArray', 'QLine', 'QLineF', 'QModelIndex', 'QPersitentModelIndex',
'QVariant', 'QFileInfo', 'QUrl', 'QXmlStreamAttribute', 'QXmlStreamNamespaceDeclaration', 'QXmlStreamNotationDeclaration',
'QXmlStreamEntityDeclaration']
#this list of types that use Q_DECLARE_TYPEINFO(T, Q_PRIMITIVE_TYPE) (from qglobal.h)
primitiveTypes = ['bool', 'char', 'signed char', 'unsigned char', 'short', 'unsigned short', 'int', 'unsigned int', 'long', 'unsigned long', 'long long', 'unsigned long long', 'float', 'double']
if movableTypes.count(self.nodetype.tag) or primitiveTypes.count(str(self.nodetype)):
isStatic = False
else:
isStatic = not isPointer
if isLarge or isStatic: #see QList::Node::t()
node = array.cast(gdb.lookup_type('QList<%s>::Node' % self.nodetype).pointer())
else:
node = array.cast(gdb.lookup_type('QList<%s>::Node' % self.nodetype))
self.count = self.count + 1
return ('[%d]' % count, node['v'].cast(self.nodetype))
def __init__(self, value, cache):
baseshape_flags = gdb.lookup_type('js::BaseShape::Flag')
self.flag_DELEGATE = prettyprinters.enum_value(baseshape_flags, 'js::BaseShape::DELEGATE')
self.func_ptr_type = gdb.lookup_type('JSFunction').pointer()
self.class_NON_NATIVE = gdb.parse_and_eval('js::Class::NON_NATIVE')
self.NativeObject_ptr_t = gdb.lookup_type('js::NativeObject').pointer()
self.Shape_ptr_t = gdb.lookup_type('js::Shape').pointer()
def invoke(self, arg, from_tty):
ptr = int(arg, 0)
owning_thread = None
for t, start, size in seastar_memory_layout():
if ptr >= start and ptr < start + size:
owning_thread = t
break
if not owning_thread:
gdb.write("Not managed by seastar\n")
return
msg = "thread %d" % t.num
owning_thread.switch()
cpu_mem = gdb.parse_and_eval('memory::cpu_mem')
page_size = int(gdb.parse_and_eval('memory::page_size'))
offset = ptr - int(cpu_mem['memory'])
page = cpu_mem['pages'][offset / page_size];
if page['free']:
msg += ', page is free'
gdb.write(msg + '\n')
return
pool = page['pool']
offset_in_span = page['offset_in_span'] * page_size + ptr % page_size
first_page_in_span = cpu_mem['pages'][offset / page_size - page['offset_in_span']];
if pool:
object_size = int(pool['_object_size'])
msg += ', small (size <= %d)' % object_size
offset_in_object = offset_in_span % object_size
free_object_ptr = gdb.lookup_type('void').pointer().pointer()
char_ptr = gdb.lookup_type('char').pointer()
# pool's free list
next_free = pool['_free']
free = False
while next_free:
if ptr >= next_free and ptr < next_free.reinterpret_cast(char_ptr) + object_size:
free = True
break
next_free = next_free.reinterpret_cast(free_object_ptr).dereference()
if not free:
# span's free list
next_free = first_page_in_span['freelist']
while next_free:
if ptr >= next_free and ptr < next_free.reinterpret_cast(char_ptr) + object_size:
free = True
break
next_free = next_free.reinterpret_cast(free_object_ptr).dereference()
if free:
msg += ', free'
else:
msg += ', live (0x%x +%d)' % (ptr - offset_in_object, offset_in_object)
else:
msg += ', large'
gdb.write(msg + '\n')
return
def init_TYPE_FLAGS(self):
"""Initialize the TYPE_FLAGS global as a list of TypeFlag objects.
This operation requires the search of a couple of enumeration types.
If not found, a warning is printed on stdout, and TYPE_FLAGS is
set to the empty list.
The resulting list is sorted by increasing value, to facilitate
printing of the list of flags used in an instance_flags value.
"""
global TYPE_FLAGS
TYPE_FLAGS = []
try:
flags = gdb.lookup_type("enum type_flag_value")
except:
print "Warning: Cannot find enum type_flag_value type."
print " `struct type' pretty-printer will be degraded"
return
try:
iflags = gdb.lookup_type("enum type_instance_flag_value")
except:
print "Warning: Cannot find enum type_instance_flag_value type."
print " `struct type' pretty-printer will be degraded"
return
# Note: TYPE_FLAG_MIN is a duplicate of TYPE_FLAG_UNSIGNED,
# so exclude it from the list we are building.
TYPE_FLAGS = [TypeFlag(field.name, field.bitpos)
for field in flags.fields()
if field.name != 'TYPE_FLAG_MIN']
TYPE_FLAGS += [TypeFlag(field.name, field.bitpos)
for field in iflags.fields()]
TYPE_FLAGS.sort()
def invoke(self, arg, from_tty):
arg_list = gdb.string_to_argv(arg)
typeobj = None
member = None
dump = False
if len(arg_list) != 1 and len(arg_list) != 3 and len(arg_list) != 4:
print("usage: ovs_dump_ovs_list <struct ovs_list *> "
"{[<structure>] [<member>] {dump}]}")
return
header = gdb.parse_and_eval(arg_list[0]).cast(
gdb.lookup_type('struct ovs_list').pointer())
if len(arg_list) >= 3:
typeobj = arg_list[1]
member = arg_list[2]
if len(arg_list) == 4 and arg_list[3] == "dump":
dump = True
for node in ForEachLIST(header.dereference()):
if typeobj is None or member is None:
print("(struct ovs_list *) {}".format(node))
else:
print("({} *) {} =".format(
typeobj,
container_of(node,
gdb.lookup_type(typeobj).pointer(), member)))
if dump:
print(" {}\n".format(container_of(
node,
gdb.lookup_type(typeobj).pointer(),
member).dereference()))
def to_string_v1(self):
try:
node = self.val['base_']['node_']
if not node:
return utils.invalid_iterator
node_type = node.type.strip_typedefs()
if node_type.code == gdb.TYPE_CODE_PTR:
node_type = node_type.target()
allocator_type = node_type.template_argument(0)
pair_type = allocator_type.template_argument(0)
value_base_type = gdb.lookup_type(
'boost::unordered_detail::value_base < %s >' % str(pair_type)).pointer()
node_pointer = gdb.lookup_type(
"boost::unordered_detail::hash_node<%s, boost::unordered_detail::ungrouped>" %
str(allocator_type)).pointer()
value_base = node.cast(node_pointer).cast(value_base_type)
pair = value_base['data_']['data_']['buf'].address.cast(pair_type.pointer()).dereference()
l = utils.pairValueToList(pair)
if utils.getParameter('boost_unordered_map_iterator_first'):
return l[0]
elif utils.getParameter('boost_unordered_map_iterator_second'):
return l[1]
else:
return utils.pairToString(l)
except gdb.error:
return utils.invalid_iterator
def to_string(self):
s_t = str(self.val['t']);
if s_t == 'lyramilk::data::var::t_invalid':
return 't_invalid'
if s_t == 'lyramilk::data::var::t_user':
return 't_user'
if s_t == 'lyramilk::data::var::t_bin':
var_chunk_type = gdb.lookup_type("lyramilk::data::chunk");
bp = self.val['u']['bp'].dereference().cast(var_chunk_type);
return 't_bin:%s' % bp
if s_t == 'lyramilk::data::var::t_str':
var_string_type = gdb.lookup_type("lyramilk::data::string");
bs = self.val['u']['bs'].dereference().cast(var_string_type);
return 't_str:%s' % bs
if s_t == 'lyramilk::data::var::t_wstr':
var_wstring_type = gdb.lookup_type("lyramilk::data::wstring");
bw = self.val['u']['bw'].dereference().cast(var_wstring_type);
return 't_wstr:%s' % bw
if s_t == 'lyramilk::data::var::t_bool':
return 't_bool:%s' % self.val['u']['b']
if s_t == 'lyramilk::data::var::t_int':
return 't_int:%s' % self.val['u']['i8']
if s_t == 'lyramilk::data::var::t_uint':
return 't_uint:%s' % self.val['u']['u8']
if s_t == 'lyramilk::data::var::t_double':
return 't_double:%s' % self.val['u']['f8']
if s_t == 'lyramilk::data::var::t_array':
return 't_array'
if s_t == 'lyramilk::data::var::t_map':
return 't_map'
def get_decorations(obj):
"""Return an iterator to all decorations on a given object.
Each object returned by the iterator is a tuple whose first element is the type name of the
decoration and whose second element is the decoration object itself.
TODO: De-duplicate the logic between here and DecorablePrinter. This code was copied from there.
"""
type_name = str(obj.type).replace(" ", "")
decorable = obj.cast(gdb.lookup_type("mongo::Decorable<{}>".format(type_name)))
decl_vector = decorable["_decorations"]["_registry"]["_decorationInfo"]
start = decl_vector["_M_impl"]["_M_start"]
finish = decl_vector["_M_impl"]["_M_finish"]
decorable_t = decorable.type.template_argument(0)
decinfo_t = gdb.lookup_type('mongo::DecorationRegistry<{}>::DecorationInfo'.format(decorable_t))
count = long((long(finish) - long(start)) / decinfo_t.sizeof)
for i in range(count):
descriptor = start[i]
dindex = int(descriptor["descriptor"]["_index"])
type_name = str(descriptor["constructor"])
type_name = type_name[0:len(type_name) - 1]
type_name = type_name[0:type_name.rindex(">")]
type_name = type_name[type_name.index("constructAt<"):].replace("constructAt<", "")
# get_unique_ptr should be loaded from 'mongo_printers.py'.
decoration_data = get_unique_ptr(decorable["_decorations"]["_decorationData"]) # pylint: disable=undefined-variable
if type_name.endswith('*'):
type_name = type_name[0:len(type_name) - 1]
type_name = type_name.rstrip()
type_t = gdb.lookup_type(type_name)
obj = decoration_data[dindex].cast(type_t)
yield (type_name, obj)
def ReadMemHexDump( address, lines, leadaddr, columnwidth=8 ):
pointer=address.cast(gdb.lookup_type('char').pointer())
sp=pointer
asciiwidth=columnwidth
hexwidth=asciiwidth*3
output=""
for a in range(0,lines):
hexline=""
asciiline=""
for b in range(0,asciiwidth):
v1 = pointer.dereference().cast(gdb.lookup_type('int')) & 0xff
v2 = binascii.hexlify(chr(v1))
if ( (v1 > 127) | (v1 == 0x0a) | (v1 == 0x0d) | (v1 == 0x0c) | (v1 == 0x0b) | (v1 == 0) | (v1 == 9) | (v1 == 8) ):
v1='.'
else:
v1=chr(v1)
hexline+= ' ' + v2
asciiline+=v1
pointer+=1
if (leadaddr):
output+=("0x" + faddress_printf) %(long(sp)) +": "
sp+=asciiwidth
output+=hexline+" "+asciiline+'\n'
address+=asciiwidth
return output
def ReadMemRaw( address, size ):
pointer=address.cast(gdb.lookup_type('char').pointer())
output=[]
for a in range(0,size):
val1= chr(pointer.dereference().cast(gdb.lookup_type('int')) & 0xff)
output.append(val1)
pointer+=1
return output
def readmemhex(self, address, size):
pointer=address.cast(gdb.lookup_type('char').pointer())
output=""
for a in range(0,size):
val1= chr(pointer.dereference().cast(gdb.lookup_type('int')) & 0xff)
output+=binascii.hexlify(val1)
pointer+=1
return output
def __init__(self, val):
self.kind = val['m_kind']
if self.kind == 0 or self.kind == 1:
self.val = val.cast(gdb.lookup_type('HPHP::HphpArray'))
elif self.kind == self.proxyKind():
self.val = val.cast(gdb.lookup_type('HPHP::ProxyArray'))
else:
self.val = val
def __init__(self, thread_data):
self.thread_data = thread_data
# current_state_ = {
# <boost::atomics::detail::base_atomic<
# hpx::threads::detail::combined_tagged_state<
# hpx::threads::thread_state_enum,
# hpx::threads::thread_state_ex_enum
# >, void>
# > = { m_storage = 360569445166350338 }, <No data fields>
# },
# component_id_ = 8198320,
# description_ = thread_description {{ [desc] {0x7ffff4aa0cb5 'call_startup_functions_action'} }},
# lco_description_ = thread_description {{ [desc] {0x7ffff4918a9d '<unknown>'} }},
# parent_locality_id_ = 0,
# parent_thread_id_ = 0x7f3090,
# parent_thread_phase_ = 1,
# marked_state_ = hpx::threads::unknown,
# priority_ = hpx::threads::thread_priority_normal,
# requested_interrupt_ = false,
# enabled_interrupt_ = true,
# ran_exit_funcs_ = false,
# exit_funcs_ = std::deque with 0 elements,
# scheduler_base_ = 0x7cf5b8,
# count_ = {
# value_ = {
# <boost::atomics::detail::base_atomic<long, int>> = {
# m_storage = 1
# }, <No data fields>
# }
# },
# stacksize_ = 131072,
# coroutine_ = {
# m_pimpl = (boost::intrusive_ptr<hpx::threads::coroutines::detail::coroutine_impl>) 0x7fffee728180
# },
# pool_ = 0x7e9a60
#}
context_impl = self.thread_data['coroutine_']['m_pimpl']['px']
self.stack_end = context_impl['m_stack'] + context_impl['m_stack_size']
self.stack_start = context_impl['m_stack']
self.m_sp = context_impl['m_sp']
self.id = context_impl['m_thread_id']
self.parent_id = self.thread_data['parent_thread_id_']
self.description = self.thread_data['description_']
self.lco_description = self.thread_data['lco_description_']
self.size_t = gdb.lookup_type('std::size_t')
combined_state = self.thread_data['current_state_']#['m_storage']
combined_state_type = combined_state.type.template_argument(0)
state_enum_type = combined_state_type.template_argument(0)
state_ex_enum_type = combined_state_type.template_argument(1)
combined_state = int('%d' % combined_state['m_storage'].cast(self.size_t))
self.state = gdb.Value((combined_state >> 56) & 0xff).cast(state_enum_type)
self.state_ex = gdb.Value((combined_state >> 48) & 0xff).cast(state_ex_enum_type)
stack = self.m_sp.reinterpret_cast(self.size_t)
self.context = HPXThread.Context()
self.context.pc = self.deref_stack(stack + (64))
self.context.r15 = self.deref_stack(stack + (8 * 0))
self.context.r14 = self.deref_stack(stack + (8 * 1))
self.context.r13 = self.deref_stack(stack + (8 * 2))
self.context.r12 = self.deref_stack(stack + (8 * 3))
self.context.rdx = self.deref_stack(stack + (8 * 4))
self.context.rax = self.deref_stack(stack + (8 * 5))
self.context.rbx = self.deref_stack(stack + (8 * 6))
self.context.rbp = self.deref_stack(stack + (8 * 7))
self.context.sp = stack + (8 * 8)
prev_context = self.context.switch()
frame = gdb.newest_frame()
function_name = frame.name()
p = re.compile('^hpx::threads::coroutines.*$')
try:
while p.match(function_name):
if frame.older() is None:
break
frame = frame.older()
function_name = frame.name()
if frame.older() is not None:
frame = frame.older()
function_name = frame.name()
line = frame.function().line
filename = frame.find_sal().symtab.filename
self.pc_string = '0x{pc:x} in {function} at {file_path}:{line}'.format(
pc=frame.pc(),
function=function_name,
file_path=filename,
line=line
)
except:
self.pc_string = '0x{pc:x} in <unknown>'.format(pc=frame.pc())
self.frame = frame
prev_context.switch()
def invoke(self, ptr, typename, elementname):
return container_of(ptr, gdb.lookup_type(typename.string()).pointer(),
elementname.string())
def address(self):
# Regression test for an overflow in the python layer.
bitsize = 8 * gdb.lookup_type('void').pointer().sizeof
mask = (1 << bitsize) - 1
return 0xffffffffffffffff & mask
def values(self):
for f in _g_array_iter(self.val["fields"],
gdb.lookup_type("GstStructureField")):
key = g_quark_to_string(f["name"])
value = GdbGValue(f["value"])
yield (key, value)
def items(self):
gdb_type = gdb.lookup_type("GstCapsArrayElement")
for f in _g_array_iter(self.val["array"], gdb_type):
yield (GdbCapsFeatures(f["features"]),
GdbGstStructure(f["structure"]))
def _lookup_type(self, typename):
if typename != '':
type = gdb.lookup_type(typename)
if type:
type = type.strip_typedefs()
return type
def name(self):
obj = self.val.cast(gdb.lookup_type("GstObject").pointer())
return obj["name"].string()
def hashNode(self):
"Casts the current QHashData::Node to a QHashNode and returns the result. See also QHash::concrete()"
return self.data_node.cast(
gdb.lookup_type('QHashNode<%s, %s>' %
(self.ktype, self.vtype)).pointer())
def type(self):
'''Gets gdb.Type for the type'''
if self.typename:
return gdb.lookup_type(str(self.typename))
return None
def concrete(self, data_node):
node_type = gdb.lookup_type('QMapNode<%s, %s>' %
(self.ktype, self.vtype)).pointer()
return (data_node.cast(gdb.lookup_type('char').pointer()) -
self.payload()).cast(node_type)
def _to_int(x):
try:
return int(gdb.parse_and_eval(x).cast(gdb.lookup_type("long")))
except BaseException as e:
print(e)
return None
STACK_SAMPLE_LENGTH = 1024
try:
gdb
except NameError:
try:
import gdb
except ImportError:
import sys
sys.stderr.write('Not running inside GDB?\n')
sys.stderr.flush()
sys.exit(1)
VOID_P_TYPE = gdb.lookup_type('void').pointer()
def list_ngrams(xs, n):
'''Generate all n-grams for given n in xs'''
cnt, _ = divmod(len(xs), n)
for i in xrange(cnt):
yield xs[i * n:(i + 1) * n]
def all_equal(xs):
'''Check whether all values in xs are equal'''
fst = sentinel = object()
def parent(self):
obj = self.val.cast(gdb.lookup_type("GstObject").pointer())
return obj["parent"]
def __init__(self, type, full_type):
full_type = full_type.cast(
gdb.lookup_type('_typelib_StructTypeDescription'))
super(StructType, self).__init__(type, full_type['aBase'])
def dot_name(self):
ptr = self.val.cast(gdb.lookup_type("void").pointer())
return re.sub('[^a-zA-Z0-9<>]', '_', "%s_%s" % (self.name(), str(ptr)))
def __init__(self, type, full_type):
super(EnumType, self).__init__(TypeClass.ENUM,
type['pTypeName'].dereference())
self.typename = self.uno2cpp(self.tag)
self._type = full_type.cast(
gdb.lookup_type('_typelib_EnumTypeDescription'))
def __init__(self, val):
self.val = val.cast(gdb.lookup_type("GstEventImpl").pointer())
def __call__(self, args):
word = gdb.lookup_type('word_t')
word_ptr = word.pointer()
word_size = word.sizeof
canary = 0xDEADC0DE
arena_list = TailQueue(global_var('arena_list'), 'link')
dangling = 0
for arena in arena_list:
start = arena['start'].cast(word)
end = arena['end'].cast(word)
print("[arena] start: 0x%X, end: 0x%X" % (start, end))
# Check boundary tag layout.
ptr = start
prevfree = False
is_last = False
while ptr < end:
btag = ptr.cast(word_ptr).dereference()
is_used = bool(btag & 1)
is_prevfree = bool(btag & 2)
is_last = bool(btag & 4)
size = btag & -8
# Ok... now let's check validity
footer_ptr = ptr + size - word_size
footer = footer_ptr.cast(word_ptr).dereference()
if is_used:
is_valid = (is_prevfree == prevfree) and (footer == canary)
prevfree = False
else:
is_valid = (btag == footer) or (not prevfree)
prevfree = True
dangling += 1
# Print the block and proceed
print(" 0x%X: [%c%c:%u] %c %s" % (
ptr, "FU"[int(is_used)], " P"[int(is_prevfree)], size,
" *"[int(is_last)], ["(invalid!)", ""][int(is_valid)]))
ptr += size
if not is_last:
print("(***) Last block set incorrectly!")
# Check buckets of free blocks.
freelst = global_var('freebins')
idx_from, idx_to = freelst.type.range()
for i in range(idx_from, idx_to + 1):
head = freelst[i].address
node = head['next']
if node == head:
continue
print("[free:%d-%d] first: 0x%X, last: 0x%X" % (
self.bins[i][0], self.bins[i][1], head['next'].cast(word),
head['prev'].cast(word)))
while node != head:
ptr = node.cast(word) - word_size
btag = ptr.cast(word_ptr).dereference()
# Ok... now let's check validity
is_used = bool(btag & 1)
is_valid = not is_used
dangling -= 1
# Print the block and proceed
print(" 0x%X: [0x%X, 0x%X] %s" % (
node.cast(word), node['prev'].cast(word),
node['next'].cast(word),
["(invalid!)", ""][int(is_valid)]))
node = node['next']
if dangling != 0:
print("(***) Some free blocks are not inserted on free list!")
def __init__(self, val):
self.val = val.cast(gdb.lookup_type("GstStructureImpl").pointer())
def __init__(self, val):
gdb_type = gdb.lookup_type("GstElement").pointer()
super(GdbGstElement, self).__init__(gdb_type, val)
self.is_bin = gst_is_bin(self.val)
def items(self):
if long(self.val) == 0:
return
for q in _g_array_iter(self.val["array"], gdb.lookup_type("GQuark")):
yield q
def events(self):
if long(self.val["priv"]) == 0:
return
array = self.val["priv"]["events"]
for ev in _g_array_iter(array, gdb.lookup_type("PadEvent")):
yield GdbGstEvent(ev["event"])
def cast_to_internal(node):
internal_type_name = node.type.target().name.replace("LeafNode", "InternalNode", 1)
internal_type = gdb.lookup_type(internal_type_name)
return node.cast(internal_type.pointer())
def __init__(self, val):
gdb_type = gdb.lookup_type("GstPad").pointer()
super(GdbGstPad, self).__init__(gdb_type, val)
def T(name):
return gdb.lookup_type(name)
def parent_element(self):
p = self.parent()
if p != 0 and g_inherits_type(p, "GstElement"):
element = p.cast(gdb.lookup_type("GstElement").pointer())
return GdbGstElement(element)
return None
def get_arg_types(self):
return gdb.lookup_type("int")
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
# THIS HEADER MAY NOT BE EXTRACTED OR MODIFIED IN ANY WAY.
import gdb
import pickle
import os, sys
import tempfile, shutil
scripts_dir = os.path.dirname(os.path.realpath(__file__))
sys.path.append(scripts_dir)
import uk_trace.parse as parse
type_char = gdb.lookup_type('char')
type_void = gdb.lookup_type('void')
PTR_SIZE = type_void.pointer().sizeof
def get_trace_buffer():
inf = gdb.selected_inferior()
try:
trace_buff = gdb.parse_and_eval('uk_trace_buffer')
trace_buff_size = trace_buff.type.sizeof
trace_buff_addr = int(trace_buff.address)
trace_buff_writep = int(gdb.parse_and_eval('uk_trace_buffer_writep'))
except gdb.error:
gdb.write("Error getting the trace buffer. Is tracing enabled?\n")
def get_arg_types(self):
return gdb.lookup_type("char")
def get_result_type(self, obj, arg):
return gdb.lookup_type("void")
