| # Copyright 2010 The Go Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style |
| # license that can be found in the LICENSE file. |
| |
| """GDB Pretty printers and convenience functions for Go's runtime structures. |
| |
| This script is loaded by GDB when it finds a .debug_gdb_scripts |
| 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. |
| |
| |
| from __future__ import print_function |
| import re |
| import sys |
| import gdb |
| |
| print("Loading Go Runtime support.", file=sys.stderr) |
| #http://python3porting.com/differences.html |
| if sys.version > '3': |
| xrange = range |
| # allow to manually reload while developing |
| goobjfile = gdb.current_objfile() or gdb.objfiles()[0] |
| goobjfile.pretty_printers = [] |
| |
| # G state (runtime2.go) |
| |
| def read_runtime_const(varname, default): |
| try: |
| return int(gdb.parse_and_eval(varname)) |
| except Exception: |
| return int(default) |
| |
| |
| G_IDLE = read_runtime_const("'runtime._Gidle'", 0) |
| G_RUNNABLE = read_runtime_const("'runtime._Grunnable'", 1) |
| G_RUNNING = read_runtime_const("'runtime._Grunning'", 2) |
| G_SYSCALL = read_runtime_const("'runtime._Gsyscall'", 3) |
| G_WAITING = read_runtime_const("'runtime._Gwaiting'", 4) |
| G_MORIBUND_UNUSED = read_runtime_const("'runtime._Gmoribund_unused'", 5) |
| G_DEAD = read_runtime_const("'runtime._Gdead'", 6) |
| G_ENQUEUE_UNUSED = read_runtime_const("'runtime._Genqueue_unused'", 7) |
| G_COPYSTACK = read_runtime_const("'runtime._Gcopystack'", 8) |
| G_SCAN = read_runtime_const("'runtime._Gscan'", 0x1000) |
| G_SCANRUNNABLE = G_SCAN+G_RUNNABLE |
| G_SCANRUNNING = G_SCAN+G_RUNNING |
| G_SCANSYSCALL = G_SCAN+G_SYSCALL |
| G_SCANWAITING = G_SCAN+G_WAITING |
| |
| sts = { |
| G_IDLE: 'idle', |
| G_RUNNABLE: 'runnable', |
| G_RUNNING: 'running', |
| G_SYSCALL: 'syscall', |
| G_WAITING: 'waiting', |
| G_MORIBUND_UNUSED: 'moribund', |
| G_DEAD: 'dead', |
| G_ENQUEUE_UNUSED: 'enqueue', |
| G_COPYSTACK: 'copystack', |
| G_SCAN: 'scan', |
| G_SCANRUNNABLE: 'runnable+s', |
| G_SCANRUNNING: 'running+s', |
| G_SCANSYSCALL: 'syscall+s', |
| G_SCANWAITING: 'waiting+s', |
| } |
| |
| |
| # |
| # Value wrappers |
| # |
| |
| class SliceValue: |
| "Wrapper for slice values." |
| |
| def __init__(self, val): |
| self.val = val |
| |
| @property |
| def len(self): |
| return int(self.val['len']) |
| |
| @property |
| def cap(self): |
| return int(self.val['cap']) |
| |
| def __getitem__(self, i): |
| if i < 0 or i >= self.len: |
| raise IndexError(i) |
| ptr = self.val["array"] |
| return (ptr + i).dereference() |
| |
| |
| # |
| # Pretty Printers |
| # |
| |
| # The patterns for matching types are permissive because gdb 8.2 switched to matching on (we think) typedef names instead of C syntax names. |
| class StringTypePrinter: |
| "Pretty print Go strings." |
| |
| pattern = re.compile(r'^(struct string( \*)?|string)$') |
| |
| def __init__(self, val): |
| self.val = val |
| |
| def display_hint(self): |
| return 'string' |
| |
| def to_string(self): |
| l = int(self.val['len']) |
| return self.val['str'].string("utf-8", "ignore", l) |
| |
| |
| class SliceTypePrinter: |
| "Pretty print slices." |
| |
| pattern = re.compile(r'^(struct \[\]|\[\])') |
| |
| def __init__(self, val): |
| self.val = val |
| |
| def display_hint(self): |
| return 'array' |
| |
| def to_string(self): |
| t = str(self.val.type) |
| if (t.startswith("struct ")): |
| return t[len("struct "):] |
| return t |
| |
| def children(self): |
| sval = SliceValue(self.val) |
| if sval.len > sval.cap: |
| return |
| for idx, item in enumerate(sval): |
| yield ('[{0}]'.format(idx), item) |
| |
| |
| # TODO(go.dev/issue/54766): Support swisstable maps. |
| class MapTypePrinter: |
| """Pretty print map[K]V types. |
| |
| Map-typed go variables are really pointers. dereference them in gdb |
| to inspect their contents with this pretty printer. |
| """ |
| |
| pattern = re.compile(r'^map\[.*\].*$') |
| |
| def __init__(self, val): |
| self.val = val |
| |
| def display_hint(self): |
| return 'map' |
| |
| def to_string(self): |
| return str(self.val.type) |
| |
| def children(self): |
| MapBucketCount = 8 # see internal/abi.go:MapBucketCount |
| B = self.val['B'] |
| buckets = self.val['buckets'] |
| oldbuckets = self.val['oldbuckets'] |
| flags = self.val['flags'] |
| inttype = self.val['hash0'].type |
| cnt = 0 |
| for bucket in xrange(2 ** int(B)): |
| bp = buckets + bucket |
| if oldbuckets: |
| oldbucket = bucket & (2 ** (B - 1) - 1) |
| oldbp = oldbuckets + oldbucket |
| oldb = oldbp.dereference() |
| if (oldb['overflow'].cast(inttype) & 1) == 0: # old bucket not evacuated yet |
| if bucket >= 2 ** (B - 1): |
| continue # already did old bucket |
| bp = oldbp |
| while bp: |
| b = bp.dereference() |
| for i in xrange(MapBucketCount): |
| if b['tophash'][i] != 0: |
| k = b['keys'][i] |
| v = b['values'][i] |
| if flags & 1: |
| k = k.dereference() |
| if flags & 2: |
| v = v.dereference() |
| yield str(cnt), k |
| yield str(cnt + 1), v |
| cnt += 2 |
| bp = b['overflow'] |
| |
| |
| class ChanTypePrinter: |
| """Pretty print chan[T] types. |
| |
| Chan-typed go variables are really pointers. dereference them in gdb |
| to inspect their contents with this pretty printer. |
| """ |
| |
| pattern = re.compile(r'^chan ') |
| |
| def __init__(self, val): |
| self.val = val |
| |
| def display_hint(self): |
| return 'array' |
| |
| def to_string(self): |
| return str(self.val.type) |
| |
| def children(self): |
| # see chan.c chanbuf(). et is the type stolen from hchan<T>::recvq->first->elem |
| et = [x.type for x in self.val['recvq']['first'].type.target().fields() if x.name == 'elem'][0] |
| ptr = (self.val.address["buf"]).cast(et) |
| for i in range(self.val["qcount"]): |
| j = (self.val["recvx"] + i) % self.val["dataqsiz"] |
| yield ('[{0}]'.format(i), (ptr + j).dereference()) |
| |
| |
| def paramtypematch(t, pattern): |
| return t.code == gdb.TYPE_CODE_TYPEDEF and str(t).startswith(".param") and pattern.match(str(t.target())) |
| |
| # |
| # Register all the *Printer classes above. |
| # |
| |
| def makematcher(klass): |
| def matcher(val): |
| try: |
| if klass.pattern.match(str(val.type)): |
| return klass(val) |
| elif paramtypematch(val.type, klass.pattern): |
| return klass(val.cast(val.type.target())) |
| except Exception: |
| pass |
| return matcher |
| |
| goobjfile.pretty_printers.extend([makematcher(var) for var in vars().values() if hasattr(var, 'pattern')]) |
| # |
| # Utilities |
| # |
| |
| def pc_to_int(pc): |
| # python2 will not cast pc (type void*) to an int cleanly |
| # instead python2 and python3 work with the hex string representation |
| # of the void pointer which we can parse back into an int. |
| # int(pc) will not work. |
| try: |
| # python3 / newer versions of gdb |
| pc = int(pc) |
| except gdb.error: |
| # str(pc) can return things like |
| # "0x429d6c <runtime.gopark+284>", so |
| # chop at first space. |
| pc = int(str(pc).split(None, 1)[0], 16) |
| return pc |
| |
| |
| # |
| # For reference, this is what we're trying to do: |
| # eface: p *(*(struct 'runtime.rtype'*)'main.e'->type_->data)->string |
| # iface: p *(*(struct 'runtime.rtype'*)'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 gdb.error: |
| pass |
| |
| |
| def is_eface(val): |
| try: |
| return str(val['_type'].type) == "struct runtime._type *" and str(val['data'].type) == "void *" |
| except gdb.error: |
| pass |
| |
| |
| def lookup_type(name): |
| try: |
| return gdb.lookup_type(name) |
| except gdb.error: |
| pass |
| try: |
| return gdb.lookup_type('struct ' + name) |
| except gdb.error: |
| pass |
| try: |
| return gdb.lookup_type('struct ' + name[1:]).pointer() |
| except gdb.error: |
| pass |
| |
| |
| def iface_commontype(obj): |
| if is_iface(obj): |
| go_type_ptr = obj['tab']['_type'] |
| elif is_eface(obj): |
| go_type_ptr = obj['_type'] |
| else: |
| return |
| |
| return go_type_ptr.cast(gdb.lookup_type("struct reflect.rtype").pointer()).dereference() |
| |
| |
| def iface_dtype(obj): |
| "Decode type of the data field of an eface or iface struct." |
| # known issue: dtype_name decoded from runtime.rtype is "nested.Foo" |
| # but the dwarf table lists it as "full/path/to/nested.Foo" |
| |
| dynamic_go_type = iface_commontype(obj) |
| if dynamic_go_type is None: |
| return |
| dtype_name = dynamic_go_type['string'].dereference()['str'].string() |
| |
| dynamic_gdb_type = lookup_type(dtype_name) |
| if dynamic_gdb_type is None: |
| return |
| |
| type_size = int(dynamic_go_type['size']) |
| uintptr_size = int(dynamic_go_type['size'].type.sizeof) # size is itself a uintptr |
| if type_size > uintptr_size: |
| dynamic_gdb_type = dynamic_gdb_type.pointer() |
| |
| return dynamic_gdb_type |
| |
| |
| def iface_dtype_name(obj): |
| "Decode type name of the data field of an eface or iface struct." |
| |
| dynamic_go_type = iface_commontype(obj) |
| if dynamic_go_type is None: |
| return |
| return dynamic_go_type['string'].dereference()['str'].string() |
| |
| |
| 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): |
| if self.val['data'] == 0: |
| return 0x0 |
| try: |
| dtype = iface_dtype(self.val) |
| except Exception: |
| return "<bad dynamic type>" |
| |
| if dtype is None: # trouble looking up, print something reasonable |
| return "({typename}){data}".format( |
| typename=iface_dtype_name(self.val), data=self.val['data']) |
| |
| try: |
| return self.val['data'].cast(dtype).dereference() |
| except Exception: |
| 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 |
| # |
| |
| |
| class GoLenFunc(gdb.Function): |
| "Length of strings, slices, maps or channels" |
| |
| how = ((StringTypePrinter, 'len'), (SliceTypePrinter, 'len'), (MapTypePrinter, 'count'), (ChanTypePrinter, 'qcount')) |
| |
| def __init__(self): |
| gdb.Function.__init__(self, "len") |
| |
| def invoke(self, obj): |
| typename = str(obj.type) |
| for klass, fld in self.how: |
| if klass.pattern.match(typename) or paramtypematch(obj.type, klass.pattern): |
| return obj[fld] |
| |
| |
| class GoCapFunc(gdb.Function): |
| "Capacity of slices or channels" |
| |
| how = ((SliceTypePrinter, 'cap'), (ChanTypePrinter, 'dataqsiz')) |
| |
| def __init__(self): |
| gdb.Function.__init__(self, "cap") |
| |
| def invoke(self, obj): |
| typename = str(obj.type) |
| for klass, fld in self.how: |
| if klass.pattern.match(typename) or paramtypematch(obj.type, klass.pattern): |
| 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): |
| gdb.Function.__init__(self, "dtype") |
| |
| def invoke(self, obj): |
| try: |
| return obj['data'].cast(iface_dtype(obj)) |
| except gdb.error: |
| pass |
| return obj |
| |
| # |
| # Commands |
| # |
| |
| def linked_list(ptr, linkfield): |
| while ptr: |
| yield ptr |
| ptr = ptr[linkfield] |
| |
| |
| class GoroutinesCmd(gdb.Command): |
| "List all goroutines." |
| |
| def __init__(self): |
| gdb.Command.__init__(self, "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 SliceValue(gdb.parse_and_eval("'runtime.allgs'")): |
| if ptr['atomicstatus']['value'] == G_DEAD: |
| continue |
| s = ' ' |
| if ptr['m']: |
| s = '*' |
| pc = ptr['sched']['pc'].cast(vp) |
| pc = pc_to_int(pc) |
| blk = gdb.block_for_pc(pc) |
| status = int(ptr['atomicstatus']['value']) |
| st = sts.get(status, "unknown(%d)" % status) |
| print(s, ptr['goid'], "{0:8s}".format(st), blk.function) |
| |
| |
| def find_goroutine(goid): |
| """ |
| find_goroutine attempts to find the goroutine identified by goid. |
| It returns a tuple of gdb.Value's representing the stack pointer |
| and program counter pointer for the goroutine. |
| |
| @param int goid |
| |
| @return tuple (gdb.Value, gdb.Value) |
| """ |
| vp = gdb.lookup_type('void').pointer() |
| for ptr in SliceValue(gdb.parse_and_eval("'runtime.allgs'")): |
| if ptr['atomicstatus']['value'] == G_DEAD: |
| continue |
| if ptr['goid'] == goid: |
| break |
| else: |
| return None, None |
| # Get the goroutine's saved state. |
| pc, sp = ptr['sched']['pc'], ptr['sched']['sp'] |
| status = ptr['atomicstatus']['value']&~G_SCAN |
| # Goroutine is not running nor in syscall, so use the info in goroutine |
| if status != G_RUNNING and status != G_SYSCALL: |
| return pc.cast(vp), sp.cast(vp) |
| |
| # If the goroutine is in a syscall, use syscallpc/sp. |
| pc, sp = ptr['syscallpc'], ptr['syscallsp'] |
| if sp != 0: |
| return pc.cast(vp), sp.cast(vp) |
| # Otherwise, the goroutine is running, so it doesn't have |
| # saved scheduler state. Find G's OS thread. |
| m = ptr['m'] |
| if m == 0: |
| return None, None |
| for thr in gdb.selected_inferior().threads(): |
| if thr.ptid[1] == m['procid']: |
| break |
| else: |
| return None, None |
| # Get scheduler state from the G's OS thread state. |
| curthr = gdb.selected_thread() |
| try: |
| thr.switch() |
| pc = gdb.parse_and_eval('$pc') |
| sp = gdb.parse_and_eval('$sp') |
| finally: |
| curthr.switch() |
| return pc.cast(vp), sp.cast(vp) |
| |
| |
| 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> |
| |
| You could pass "all" as <goid> to apply <gdbcmd> to all goroutines. |
| |
| For example: (gdb) goroutine all <gdbcmd> |
| |
| Note that it is ill-defined to modify state in the context of a goroutine. |
| Restrict yourself to inspecting values. |
| """ |
| |
| def __init__(self): |
| gdb.Command.__init__(self, "goroutine", gdb.COMMAND_STACK, gdb.COMPLETE_NONE) |
| |
| def invoke(self, arg, _from_tty): |
| goid_str, cmd = arg.split(None, 1) |
| goids = [] |
| |
| if goid_str == 'all': |
| for ptr in SliceValue(gdb.parse_and_eval("'runtime.allgs'")): |
| goids.append(int(ptr['goid'])) |
| else: |
| goids = [int(gdb.parse_and_eval(goid_str))] |
| |
| for goid in goids: |
| self.invoke_per_goid(goid, cmd) |
| |
| def invoke_per_goid(self, goid, cmd): |
| pc, sp = find_goroutine(goid) |
| if not pc: |
| print("No such goroutine: ", goid) |
| return |
| pc = pc_to_int(pc) |
| save_frame = gdb.selected_frame() |
| gdb.parse_and_eval('$save_sp = $sp') |
| gdb.parse_and_eval('$save_pc = $pc') |
| # In GDB, assignments to sp must be done from the |
| # top-most frame, so select frame 0 first. |
| gdb.execute('select-frame 0') |
| gdb.parse_and_eval('$sp = {0}'.format(str(sp))) |
| gdb.parse_and_eval('$pc = {0}'.format(str(pc))) |
| try: |
| gdb.execute(cmd) |
| finally: |
| # In GDB, assignments to sp must be done from the |
| # top-most frame, so select frame 0 first. |
| gdb.execute('select-frame 0') |
| 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): |
| gdb.Command.__init__(self, "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(str(obj)) |
| except Exception as e: |
| print("Can't parse ", obj, ": ", e) |
| continue |
| |
| if obj['data'] == 0: |
| dtype = "nil" |
| else: |
| dtype = iface_dtype(obj) |
| |
| if dtype is None: |
| print("Not an interface: ", obj.type) |
| continue |
| |
| print("{0}: {1}".format(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 convenience functions and CLI commands |
| # |
| GoLenFunc() |
| GoCapFunc() |
| DTypeFunc() |
| GoroutinesCmd() |
| GoroutineCmd() |
| GoIfaceCmd() |