mirror of
https://github.com/golang/go.git
synced 2025-12-08 06:10:04 +00:00
[68]l and runtime: GDB support for interfaces and goroutines.
R=rsc CC=golang-dev https://golang.org/cl/3477041
This commit is contained in:
Luuk van Dijk
parent
d96685ed6a
commit
7a4ce23d65
3 changed files with 280 additions and 34 deletions
|
|
@ -9,10 +9,20 @@ section in the compiled binary. The [68]l linkers emit this with a
|
|||
path to this file based on the path to the runtime package.
|
||||
"""
|
||||
|
||||
# Known issues:
|
||||
# - pretty printing only works for the 'native' strings. E.g. 'type
|
||||
# foo string' will make foo a plain struct in the eyes of gdb,
|
||||
# circumventing the pretty print triggering.
|
||||
# -
|
||||
|
||||
import sys, re
|
||||
|
||||
print >>sys.stderr, "Loading Go Runtime support."
|
||||
|
||||
# allow to manually reload while developing
|
||||
goobjfile = gdb.current_objfile() or gdb.objfiles()[0]
|
||||
goobjfile.pretty_printers = []
|
||||
|
||||
#
|
||||
# Pretty Printers
|
||||
#
|
||||
|
|
@ -95,7 +105,7 @@ class MapTypePrinter:
|
|||
class ChanTypePrinter:
|
||||
"""Pretty print chan[T] types.
|
||||
|
||||
Map-typed go variables are really pointers. dereference them in gdb
|
||||
Chan-typed go variables are really pointers. dereference them in gdb
|
||||
to inspect their contents with this pretty printer.
|
||||
"""
|
||||
|
||||
|
|
@ -117,18 +127,109 @@ class ChanTypePrinter:
|
|||
ptr = ptr['link']
|
||||
|
||||
#
|
||||
# Register all the *Printer classes
|
||||
# Register all the *Printer classes above.
|
||||
#
|
||||
|
||||
def makematcher(klass):
|
||||
def matcher(val):
|
||||
try:
|
||||
if klass.pattern.match(str(val.type)): return klass(val)
|
||||
except: pass
|
||||
if klass.pattern.match(str(val.type)):
|
||||
return klass(val)
|
||||
except:
|
||||
pass
|
||||
return matcher
|
||||
|
||||
gdb.current_objfile().pretty_printers.extend([makematcher(k) for k in vars().values() if hasattr(k, 'pattern')])
|
||||
goobjfile.pretty_printers.extend([makematcher(k) for k in vars().values() if hasattr(k, 'pattern')])
|
||||
|
||||
#
|
||||
# For reference, this is what we're trying to do:
|
||||
# eface: p *(*(struct 'runtime.commonType'*)'main.e'->type_->data)->string
|
||||
# iface: p *(*(struct 'runtime.commonType'*)'main.s'->tab->Type->data)->string
|
||||
#
|
||||
# interface types can't be recognized by their name, instead we check
|
||||
# if they have the expected fields. Unfortunately the mapping of
|
||||
# fields to python attributes in gdb.py isn't complete: you can't test
|
||||
# for presence other than by trapping.
|
||||
|
||||
|
||||
def is_iface(val):
|
||||
try:
|
||||
return str(val['tab'].type) == "struct runtime.itab *" \
|
||||
and str(val['data'].type) == "void *"
|
||||
except:
|
||||
pass
|
||||
|
||||
def is_eface(val):
|
||||
try:
|
||||
return str(val['type_'].type) == "runtime.Type *" \
|
||||
and str(val['data'].type) == "void *"
|
||||
except:
|
||||
pass
|
||||
|
||||
def lookup_type(name):
|
||||
try:
|
||||
return gdb.lookup_type(name)
|
||||
except:
|
||||
pass
|
||||
try:
|
||||
return gdb.lookup_type('struct ' + name)
|
||||
except:
|
||||
pass
|
||||
try:
|
||||
return gdb.lookup_type('struct ' + name[1:]).pointer()
|
||||
except:
|
||||
pass
|
||||
|
||||
|
||||
def iface_dtype(obj):
|
||||
"Decode type of the data field of an eface or iface struct."
|
||||
|
||||
if is_iface(obj):
|
||||
go_type_ptr = obj['tab']['Type']
|
||||
elif is_eface(obj):
|
||||
go_type_ptr = obj['type_']
|
||||
else:
|
||||
return
|
||||
|
||||
ct = gdb.lookup_type("struct runtime.commonType").pointer()
|
||||
dynamic_go_type = go_type_ptr['data'].cast(ct).dereference()
|
||||
dtype_name = dynamic_go_type['string'].dereference()['str'].string()
|
||||
type_size = int(dynamic_go_type['size'])
|
||||
uintptr_size = int(dynamic_go_type['size'].type.sizeof) # size is itself an uintptr
|
||||
dynamic_gdb_type = lookup_type(dtype_name)
|
||||
if type_size > uintptr_size:
|
||||
dynamic_gdb_type = dynamic_gdb_type.pointer()
|
||||
return dynamic_gdb_type
|
||||
|
||||
|
||||
class IfacePrinter:
|
||||
"""Pretty print interface values
|
||||
|
||||
Casts the data field to the appropriate dynamic type."""
|
||||
|
||||
def __init__(self, val):
|
||||
self.val = val
|
||||
|
||||
def display_hint(self):
|
||||
return 'string'
|
||||
|
||||
def to_string(self):
|
||||
try:
|
||||
dtype = iface_dtype(self.val)
|
||||
except:
|
||||
return "<bad dynamic type>"
|
||||
try:
|
||||
return self.val['data'].cast(dtype).dereference()
|
||||
except:
|
||||
pass
|
||||
return self.val['data'].cast(dtype)
|
||||
|
||||
|
||||
def ifacematcher(val):
|
||||
if is_iface(val) or is_eface(val):
|
||||
return IfacePrinter(val)
|
||||
|
||||
goobjfile.pretty_printers.append(ifacematcher)
|
||||
|
||||
#
|
||||
# Convenience Functions
|
||||
|
|
@ -137,35 +238,158 @@ gdb.current_objfile().pretty_printers.extend([makematcher(k) for k in vars().val
|
|||
class GoLenFunc(gdb.Function):
|
||||
"Length of strings, slices, maps or channels"
|
||||
|
||||
how = ((StringTypePrinter, 'len' ),
|
||||
(SliceTypePrinter, 'len'),
|
||||
(MapTypePrinter, 'count'),
|
||||
(ChanTypePrinter, 'qcount'))
|
||||
how = ((StringTypePrinter, 'len' ),
|
||||
(SliceTypePrinter, 'len'),
|
||||
(MapTypePrinter, 'count'),
|
||||
(ChanTypePrinter, 'qcount'))
|
||||
|
||||
def __init__(self):
|
||||
super(GoLenFunc, self).__init__("len")
|
||||
|
||||
def invoke(self, obj):
|
||||
typename = str(obj.type)
|
||||
for klass, fld in self.how:
|
||||
for klass, fld in self.how:
|
||||
if klass.pattern.match(typename):
|
||||
return obj[fld]
|
||||
|
||||
class GoCapFunc(gdb.Function):
|
||||
"Capacity of slices or channels"
|
||||
|
||||
how = ((SliceTypePrinter, 'cap'),
|
||||
(ChanTypePrinter, 'dataqsiz'))
|
||||
how = ((SliceTypePrinter, 'cap'),
|
||||
(ChanTypePrinter, 'dataqsiz'))
|
||||
|
||||
def __init__(self):
|
||||
super(GoCapFunc, self).__init__("cap")
|
||||
|
||||
def invoke(self, obj):
|
||||
typename = str(obj.type)
|
||||
for klass, fld in self.how:
|
||||
for klass, fld in self.how:
|
||||
if klass.pattern.match(typename):
|
||||
return obj[fld]
|
||||
|
||||
class DTypeFunc(gdb.Function):
|
||||
"""Cast Interface values to their dynamic type.
|
||||
|
||||
For non-interface types this behaves as the identity operation.
|
||||
"""
|
||||
|
||||
def __init__(self):
|
||||
super(DTypeFunc, self).__init__("dtype")
|
||||
|
||||
def invoke(self, obj):
|
||||
try:
|
||||
return obj['data'].cast(iface_dtype(obj))
|
||||
except:
|
||||
pass
|
||||
return obj
|
||||
|
||||
#
|
||||
# Commands
|
||||
#
|
||||
|
||||
sts = ( 'idle', 'runnable', 'running', 'syscall', 'waiting', 'moribund', 'dead', 'recovery')
|
||||
|
||||
def linked_list(ptr, linkfield):
|
||||
while ptr:
|
||||
yield ptr
|
||||
ptr = ptr[linkfield]
|
||||
|
||||
|
||||
class GoroutinesCmd(gdb.Command):
|
||||
"List all goroutines."
|
||||
|
||||
def __init__(self):
|
||||
super(GoroutinesCmd, self).__init__("info goroutines", gdb.COMMAND_STACK, gdb.COMPLETE_NONE)
|
||||
|
||||
def invoke(self, arg, from_tty):
|
||||
# args = gdb.string_to_argv(arg)
|
||||
vp = gdb.lookup_type('void').pointer()
|
||||
for ptr in linked_list(gdb.parse_and_eval("'runtime.allg'"), 'alllink'):
|
||||
if ptr['status'] == 6: # 'gdead'
|
||||
continue
|
||||
m = ptr['m']
|
||||
s = ' '
|
||||
if m:
|
||||
pc = m['sched']['pc'].cast(vp)
|
||||
sp = m['sched']['sp'].cast(vp)
|
||||
s = '*'
|
||||
else:
|
||||
pc = ptr['sched']['pc'].cast(vp)
|
||||
sp = ptr['sched']['sp'].cast(vp)
|
||||
blk = gdb.block_for_pc(long((pc)))
|
||||
print s, ptr['goid'], "%8s" % sts[long((ptr['status']))], blk.function
|
||||
|
||||
def find_goroutine(goid):
|
||||
vp = gdb.lookup_type('void').pointer()
|
||||
for ptr in linked_list(gdb.parse_and_eval("'runtime.allg'"), 'alllink'):
|
||||
if ptr['status'] == 6: # 'gdead'
|
||||
continue
|
||||
if ptr['goid'] == goid:
|
||||
return [(ptr['m'] or ptr)['sched'][x].cast(vp) for x in 'pc', 'sp']
|
||||
return None, None
|
||||
|
||||
|
||||
class GoroutineCmd(gdb.Command):
|
||||
"""Execute gdb command in the context of goroutine <goid>.
|
||||
|
||||
Switch PC and SP to the ones in the goroutine's G structure,
|
||||
execute an arbitrary gdb command, and restore PC and SP.
|
||||
|
||||
Usage: (gdb) goroutine <goid> <gdbcmd>
|
||||
|
||||
Note that it is ill-defined to modify state in the context of a goroutine.
|
||||
Restrict yourself to inspecting values.
|
||||
"""
|
||||
|
||||
def __init__(self):
|
||||
super(GoroutineCmd, self).__init__("goroutine", gdb.COMMAND_STACK, gdb.COMPLETE_NONE)
|
||||
|
||||
def invoke(self, arg, from_tty):
|
||||
goid, cmd = arg.split(None, 1)
|
||||
pc, sp = find_goroutine(int(goid))
|
||||
if not pc:
|
||||
print "No such goroutine: ", goid
|
||||
return
|
||||
save_frame = gdb.selected_frame()
|
||||
gdb.parse_and_eval('$save_pc = $pc')
|
||||
gdb.parse_and_eval('$save_sp = $sp')
|
||||
gdb.parse_and_eval('$pc = 0x%x' % long(pc))
|
||||
gdb.parse_and_eval('$sp = 0x%x' % long(sp))
|
||||
try:
|
||||
gdb.execute(cmd)
|
||||
finally:
|
||||
gdb.parse_and_eval('$pc = $save_pc')
|
||||
gdb.parse_and_eval('$sp = $save_sp')
|
||||
save_frame.select()
|
||||
|
||||
|
||||
class GoIfaceCmd(gdb.Command):
|
||||
"Print Static and dynamic interface types"
|
||||
|
||||
def __init__(self):
|
||||
super(GoIfaceCmd, self).__init__("iface", gdb.COMMAND_DATA, gdb.COMPLETE_SYMBOL)
|
||||
|
||||
def invoke(self, arg, from_tty):
|
||||
for obj in gdb.string_to_argv(arg):
|
||||
try:
|
||||
#TODO fix quoting for qualified variable names
|
||||
obj = gdb.parse_and_eval("%s" % obj)
|
||||
except Exception, e:
|
||||
print "Can't parse ", obj, ": ", e
|
||||
continue
|
||||
|
||||
dtype = iface_dtype(obj)
|
||||
if not dtype:
|
||||
print "Not an interface: ", obj.type
|
||||
continue
|
||||
|
||||
print "%s: %s" % (obj.type, dtype)
|
||||
|
||||
# TODO: print interface's methods and dynamic type's func pointers thereof.
|
||||
#rsc: "to find the number of entries in the itab's Fn field look at itab.inter->numMethods
|
||||
#i am sure i have the names wrong but look at the interface type and its method count"
|
||||
# so Itype will start with a commontype which has kind = interface
|
||||
|
||||
#
|
||||
# Register all convience functions and CLI commands
|
||||
#
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue