Text file src/runtime/runtime-gdb.py

     1  # Copyright 2010 The Go Authors. All rights reserved.
     2  # Use of this source code is governed by a BSD-style
     3  # license that can be found in the LICENSE file.
     4  
     5  """GDB Pretty printers and convenience functions for Go's runtime structures.
     6  
     7  This script is loaded by GDB when it finds a .debug_gdb_scripts
     8  section in the compiled binary. The [68]l linkers emit this with a
     9  path to this file based on the path to the runtime package.
    10  """
    11  
    12  # Known issues:
    13  #    - pretty printing only works for the 'native' strings. E.g. 'type
    14  #      foo string' will make foo a plain struct in the eyes of gdb,
    15  #      circumventing the pretty print triggering.
    16  
    17  
    18  from __future__ import print_function
    19  import re
    20  import sys
    21  import gdb
    22  
    23  print("Loading Go Runtime support.", file=sys.stderr)
    24  #http://python3porting.com/differences.html
    25  if sys.version > '3':
    26  	xrange = range
    27  # allow to manually reload while developing
    28  goobjfile = gdb.current_objfile() or gdb.objfiles()[0]
    29  goobjfile.pretty_printers = []
    30  
    31  # G state (runtime2.go)
    32  
    33  def read_runtime_const(varname, default):
    34    try:
    35      return int(gdb.parse_and_eval(varname))
    36    except Exception:
    37      return int(default)
    38  
    39  
    40  G_IDLE = read_runtime_const("'runtime._Gidle'", 0)
    41  G_RUNNABLE = read_runtime_const("'runtime._Grunnable'", 1)
    42  G_RUNNING = read_runtime_const("'runtime._Grunning'", 2)
    43  G_SYSCALL = read_runtime_const("'runtime._Gsyscall'", 3)
    44  G_WAITING = read_runtime_const("'runtime._Gwaiting'", 4)
    45  G_MORIBUND_UNUSED = read_runtime_const("'runtime._Gmoribund_unused'", 5)
    46  G_DEAD = read_runtime_const("'runtime._Gdead'", 6)
    47  G_ENQUEUE_UNUSED = read_runtime_const("'runtime._Genqueue_unused'", 7)
    48  G_COPYSTACK = read_runtime_const("'runtime._Gcopystack'", 8)
    49  G_SCAN = read_runtime_const("'runtime._Gscan'", 0x1000)
    50  G_SCANRUNNABLE = G_SCAN+G_RUNNABLE
    51  G_SCANRUNNING = G_SCAN+G_RUNNING
    52  G_SCANSYSCALL = G_SCAN+G_SYSCALL
    53  G_SCANWAITING = G_SCAN+G_WAITING
    54  
    55  sts = {
    56      G_IDLE: 'idle',
    57      G_RUNNABLE: 'runnable',
    58      G_RUNNING: 'running',
    59      G_SYSCALL: 'syscall',
    60      G_WAITING: 'waiting',
    61      G_MORIBUND_UNUSED: 'moribund',
    62      G_DEAD: 'dead',
    63      G_ENQUEUE_UNUSED: 'enqueue',
    64      G_COPYSTACK: 'copystack',
    65      G_SCAN: 'scan',
    66      G_SCANRUNNABLE: 'runnable+s',
    67      G_SCANRUNNING: 'running+s',
    68      G_SCANSYSCALL: 'syscall+s',
    69      G_SCANWAITING: 'waiting+s',
    70  }
    71  
    72  
    73  #
    74  #  Value wrappers
    75  #
    76  
    77  class SliceValue:
    78  	"Wrapper for slice values."
    79  
    80  	def __init__(self, val):
    81  		self.val = val
    82  
    83  	@property
    84  	def len(self):
    85  		return int(self.val['len'])
    86  
    87  	@property
    88  	def cap(self):
    89  		return int(self.val['cap'])
    90  
    91  	def __getitem__(self, i):
    92  		if i < 0 or i >= self.len:
    93  			raise IndexError(i)
    94  		ptr = self.val["array"]
    95  		return (ptr + i).dereference()
    96  
    97  
    98  #
    99  #  Pretty Printers
   100  #
   101  
   102  # The patterns for matching types are permissive because gdb 8.2 switched to matching on (we think) typedef names instead of C syntax names.
   103  class StringTypePrinter:
   104  	"Pretty print Go strings."
   105  
   106  	pattern = re.compile(r'^(struct string( \*)?|string)$')
   107  
   108  	def __init__(self, val):
   109  		self.val = val
   110  
   111  	def display_hint(self):
   112  		return 'string'
   113  
   114  	def to_string(self):
   115  		l = int(self.val['len'])
   116  		return self.val['str'].string("utf-8", "ignore", l)
   117  
   118  
   119  class SliceTypePrinter:
   120  	"Pretty print slices."
   121  
   122  	pattern = re.compile(r'^(struct \[\]|\[\])')
   123  
   124  	def __init__(self, val):
   125  		self.val = val
   126  
   127  	def display_hint(self):
   128  		return 'array'
   129  
   130  	def to_string(self):
   131  		t = str(self.val.type)
   132  		if (t.startswith("struct ")):
   133  			return t[len("struct "):]
   134  		return t
   135  
   136  	def children(self):
   137  		sval = SliceValue(self.val)
   138  		if sval.len > sval.cap:
   139  			return
   140  		for idx, item in enumerate(sval):
   141  			yield ('[{0}]'.format(idx), item)
   142  
   143  
   144  class MapTypePrinter:
   145  	"""Pretty print map[K]V types.
   146  
   147  	Map-typed go variables are really pointers. dereference them in gdb
   148  	to inspect their contents with this pretty printer.
   149  	"""
   150  
   151  	pattern = re.compile(r'^map\[.*\].*$')
   152  
   153  	def __init__(self, val):
   154  		self.val = val
   155  
   156  	def display_hint(self):
   157  		return 'map'
   158  
   159  	def to_string(self):
   160  		return str(self.val.type)
   161  
   162  	def children(self):
   163  		B = self.val['B']
   164  		buckets = self.val['buckets']
   165  		oldbuckets = self.val['oldbuckets']
   166  		flags = self.val['flags']
   167  		inttype = self.val['hash0'].type
   168  		cnt = 0
   169  		for bucket in xrange(2 ** int(B)):
   170  			bp = buckets + bucket
   171  			if oldbuckets:
   172  				oldbucket = bucket & (2 ** (B - 1) - 1)
   173  				oldbp = oldbuckets + oldbucket
   174  				oldb = oldbp.dereference()
   175  				if (oldb['overflow'].cast(inttype) & 1) == 0:  # old bucket not evacuated yet
   176  					if bucket >= 2 ** (B - 1):
   177  						continue    # already did old bucket
   178  					bp = oldbp
   179  			while bp:
   180  				b = bp.dereference()
   181  				for i in xrange(8):
   182  					if b['tophash'][i] != 0:
   183  						k = b['keys'][i]
   184  						v = b['values'][i]
   185  						if flags & 1:
   186  							k = k.dereference()
   187  						if flags & 2:
   188  							v = v.dereference()
   189  						yield str(cnt), k
   190  						yield str(cnt + 1), v
   191  						cnt += 2
   192  				bp = b['overflow']
   193  
   194  
   195  class ChanTypePrinter:
   196  	"""Pretty print chan[T] types.
   197  
   198  	Chan-typed go variables are really pointers. dereference them in gdb
   199  	to inspect their contents with this pretty printer.
   200  	"""
   201  
   202  	pattern = re.compile(r'^chan ')
   203  
   204  	def __init__(self, val):
   205  		self.val = val
   206  
   207  	def display_hint(self):
   208  		return 'array'
   209  
   210  	def to_string(self):
   211  		return str(self.val.type)
   212  
   213  	def children(self):
   214  		# see chan.c chanbuf(). et is the type stolen from hchan<T>::recvq->first->elem
   215  		et = [x.type for x in self.val['recvq']['first'].type.target().fields() if x.name == 'elem'][0]
   216  		ptr = (self.val.address["buf"]).cast(et)
   217  		for i in range(self.val["qcount"]):
   218  			j = (self.val["recvx"] + i) % self.val["dataqsiz"]
   219  			yield ('[{0}]'.format(i), (ptr + j).dereference())
   220  
   221  
   222  #
   223  #  Register all the *Printer classes above.
   224  #
   225  
   226  def makematcher(klass):
   227  	def matcher(val):
   228  		try:
   229  			if klass.pattern.match(str(val.type)):
   230  				return klass(val)
   231  		except Exception:
   232  			pass
   233  	return matcher
   234  
   235  goobjfile.pretty_printers.extend([makematcher(var) for var in vars().values() if hasattr(var, 'pattern')])
   236  #
   237  #  Utilities
   238  #
   239  
   240  def pc_to_int(pc):
   241  	# python2 will not cast pc (type void*) to an int cleanly
   242  	# instead python2 and python3 work with the hex string representation
   243  	# of the void pointer which we can parse back into an int.
   244  	# int(pc) will not work.
   245  	try:
   246  		# python3 / newer versions of gdb
   247  		pc = int(pc)
   248  	except gdb.error:
   249  		# str(pc) can return things like
   250  		# "0x429d6c <runtime.gopark+284>", so
   251  		# chop at first space.
   252  		pc = int(str(pc).split(None, 1)[0], 16)
   253  	return pc
   254  
   255  
   256  #
   257  #  For reference, this is what we're trying to do:
   258  #  eface: p *(*(struct 'runtime.rtype'*)'main.e'->type_->data)->string
   259  #  iface: p *(*(struct 'runtime.rtype'*)'main.s'->tab->Type->data)->string
   260  #
   261  # interface types can't be recognized by their name, instead we check
   262  # if they have the expected fields.  Unfortunately the mapping of
   263  # fields to python attributes in gdb.py isn't complete: you can't test
   264  # for presence other than by trapping.
   265  
   266  
   267  def is_iface(val):
   268  	try:
   269  		return str(val['tab'].type) == "struct runtime.itab *" and str(val['data'].type) == "void *"
   270  	except gdb.error:
   271  		pass
   272  
   273  
   274  def is_eface(val):
   275  	try:
   276  		return str(val['_type'].type) == "struct runtime._type *" and str(val['data'].type) == "void *"
   277  	except gdb.error:
   278  		pass
   279  
   280  
   281  def lookup_type(name):
   282  	try:
   283  		return gdb.lookup_type(name)
   284  	except gdb.error:
   285  		pass
   286  	try:
   287  		return gdb.lookup_type('struct ' + name)
   288  	except gdb.error:
   289  		pass
   290  	try:
   291  		return gdb.lookup_type('struct ' + name[1:]).pointer()
   292  	except gdb.error:
   293  		pass
   294  
   295  
   296  def iface_commontype(obj):
   297  	if is_iface(obj):
   298  		go_type_ptr = obj['tab']['_type']
   299  	elif is_eface(obj):
   300  		go_type_ptr = obj['_type']
   301  	else:
   302  		return
   303  
   304  	return go_type_ptr.cast(gdb.lookup_type("struct reflect.rtype").pointer()).dereference()
   305  
   306  
   307  def iface_dtype(obj):
   308  	"Decode type of the data field of an eface or iface struct."
   309  	# known issue: dtype_name decoded from runtime.rtype is "nested.Foo"
   310  	# but the dwarf table lists it as "full/path/to/nested.Foo"
   311  
   312  	dynamic_go_type = iface_commontype(obj)
   313  	if dynamic_go_type is None:
   314  		return
   315  	dtype_name = dynamic_go_type['string'].dereference()['str'].string()
   316  
   317  	dynamic_gdb_type = lookup_type(dtype_name)
   318  	if dynamic_gdb_type is None:
   319  		return
   320  
   321  	type_size = int(dynamic_go_type['size'])
   322  	uintptr_size = int(dynamic_go_type['size'].type.sizeof)	 # size is itself an uintptr
   323  	if type_size > uintptr_size:
   324  			dynamic_gdb_type = dynamic_gdb_type.pointer()
   325  
   326  	return dynamic_gdb_type
   327  
   328  
   329  def iface_dtype_name(obj):
   330  	"Decode type name of the data field of an eface or iface struct."
   331  
   332  	dynamic_go_type = iface_commontype(obj)
   333  	if dynamic_go_type is None:
   334  		return
   335  	return dynamic_go_type['string'].dereference()['str'].string()
   336  
   337  
   338  class IfacePrinter:
   339  	"""Pretty print interface values
   340  
   341  	Casts the data field to the appropriate dynamic type."""
   342  
   343  	def __init__(self, val):
   344  		self.val = val
   345  
   346  	def display_hint(self):
   347  		return 'string'
   348  
   349  	def to_string(self):
   350  		if self.val['data'] == 0:
   351  			return 0x0
   352  		try:
   353  			dtype = iface_dtype(self.val)
   354  		except Exception:
   355  			return "<bad dynamic type>"
   356  
   357  		if dtype is None:  # trouble looking up, print something reasonable
   358  			return "({typename}){data}".format(
   359  				typename=iface_dtype_name(self.val), data=self.val['data'])
   360  
   361  		try:
   362  			return self.val['data'].cast(dtype).dereference()
   363  		except Exception:
   364  			pass
   365  		return self.val['data'].cast(dtype)
   366  
   367  
   368  def ifacematcher(val):
   369  	if is_iface(val) or is_eface(val):
   370  		return IfacePrinter(val)
   371  
   372  goobjfile.pretty_printers.append(ifacematcher)
   373  
   374  #
   375  #  Convenience Functions
   376  #
   377  
   378  
   379  class GoLenFunc(gdb.Function):
   380  	"Length of strings, slices, maps or channels"
   381  
   382  	how = ((StringTypePrinter, 'len'), (SliceTypePrinter, 'len'), (MapTypePrinter, 'count'), (ChanTypePrinter, 'qcount'))
   383  
   384  	def __init__(self):
   385  		gdb.Function.__init__(self, "len")
   386  
   387  	def invoke(self, obj):
   388  		typename = str(obj.type)
   389  		for klass, fld in self.how:
   390  			if klass.pattern.match(typename):
   391  				return obj[fld]
   392  
   393  
   394  class GoCapFunc(gdb.Function):
   395  	"Capacity of slices or channels"
   396  
   397  	how = ((SliceTypePrinter, 'cap'), (ChanTypePrinter, 'dataqsiz'))
   398  
   399  	def __init__(self):
   400  		gdb.Function.__init__(self, "cap")
   401  
   402  	def invoke(self, obj):
   403  		typename = str(obj.type)
   404  		for klass, fld in self.how:
   405  			if klass.pattern.match(typename):
   406  				return obj[fld]
   407  
   408  
   409  class DTypeFunc(gdb.Function):
   410  	"""Cast Interface values to their dynamic type.
   411  
   412  	For non-interface types this behaves as the identity operation.
   413  	"""
   414  
   415  	def __init__(self):
   416  		gdb.Function.__init__(self, "dtype")
   417  
   418  	def invoke(self, obj):
   419  		try:
   420  			return obj['data'].cast(iface_dtype(obj))
   421  		except gdb.error:
   422  			pass
   423  		return obj
   424  
   425  #
   426  #  Commands
   427  #
   428  
   429  def linked_list(ptr, linkfield):
   430  	while ptr:
   431  		yield ptr
   432  		ptr = ptr[linkfield]
   433  
   434  
   435  class GoroutinesCmd(gdb.Command):
   436  	"List all goroutines."
   437  
   438  	def __init__(self):
   439  		gdb.Command.__init__(self, "info goroutines", gdb.COMMAND_STACK, gdb.COMPLETE_NONE)
   440  
   441  	def invoke(self, _arg, _from_tty):
   442  		# args = gdb.string_to_argv(arg)
   443  		vp = gdb.lookup_type('void').pointer()
   444  		for ptr in SliceValue(gdb.parse_and_eval("'runtime.allgs'")):
   445  			if ptr['atomicstatus'] == G_DEAD:
   446  				continue
   447  			s = ' '
   448  			if ptr['m']:
   449  				s = '*'
   450  			pc = ptr['sched']['pc'].cast(vp)
   451  			pc = pc_to_int(pc)
   452  			blk = gdb.block_for_pc(pc)
   453  			status = int(ptr['atomicstatus'])
   454  			st = sts.get(status, "unknown(%d)" % status)
   455  			print(s, ptr['goid'], "{0:8s}".format(st), blk.function)
   456  
   457  
   458  def find_goroutine(goid):
   459  	"""
   460  	find_goroutine attempts to find the goroutine identified by goid.
   461  	It returns a tuple of gdb.Value's representing the stack pointer
   462  	and program counter pointer for the goroutine.
   463  
   464  	@param int goid
   465  
   466  	@return tuple (gdb.Value, gdb.Value)
   467  	"""
   468  	vp = gdb.lookup_type('void').pointer()
   469  	for ptr in SliceValue(gdb.parse_and_eval("'runtime.allgs'")):
   470  		if ptr['atomicstatus'] == G_DEAD:
   471  			continue
   472  		if ptr['goid'] == goid:
   473  			break
   474  	else:
   475  		return None, None
   476  	# Get the goroutine's saved state.
   477  	pc, sp = ptr['sched']['pc'], ptr['sched']['sp']
   478  	status = ptr['atomicstatus']&~G_SCAN
   479  	# Goroutine is not running nor in syscall, so use the info in goroutine
   480  	if status != G_RUNNING and status != G_SYSCALL:
   481  		return pc.cast(vp), sp.cast(vp)
   482  
   483  	# If the goroutine is in a syscall, use syscallpc/sp.
   484  	pc, sp = ptr['syscallpc'], ptr['syscallsp']
   485  	if sp != 0:
   486  		return pc.cast(vp), sp.cast(vp)
   487  	# Otherwise, the goroutine is running, so it doesn't have
   488  	# saved scheduler state. Find G's OS thread.
   489  	m = ptr['m']
   490  	if m == 0:
   491  		return None, None
   492  	for thr in gdb.selected_inferior().threads():
   493  		if thr.ptid[1] == m['procid']:
   494  			break
   495  	else:
   496  		return None, None
   497  	# Get scheduler state from the G's OS thread state.
   498  	curthr = gdb.selected_thread()
   499  	try:
   500  		thr.switch()
   501  		pc = gdb.parse_and_eval('$pc')
   502  		sp = gdb.parse_and_eval('$sp')
   503  	finally:
   504  		curthr.switch()
   505  	return pc.cast(vp), sp.cast(vp)
   506  
   507  
   508  class GoroutineCmd(gdb.Command):
   509  	"""Execute gdb command in the context of goroutine <goid>.
   510  
   511  	Switch PC and SP to the ones in the goroutine's G structure,
   512  	execute an arbitrary gdb command, and restore PC and SP.
   513  
   514  	Usage: (gdb) goroutine <goid> <gdbcmd>
   515  
   516  	You could pass "all" as <goid> to apply <gdbcmd> to all goroutines.
   517  
   518  	For example: (gdb) goroutine all <gdbcmd>
   519  
   520  	Note that it is ill-defined to modify state in the context of a goroutine.
   521  	Restrict yourself to inspecting values.
   522  	"""
   523  
   524  	def __init__(self):
   525  		gdb.Command.__init__(self, "goroutine", gdb.COMMAND_STACK, gdb.COMPLETE_NONE)
   526  
   527  	def invoke(self, arg, _from_tty):
   528  		goid_str, cmd = arg.split(None, 1)
   529  		goids = []
   530  
   531  		if goid_str == 'all':
   532  			for ptr in SliceValue(gdb.parse_and_eval("'runtime.allgs'")):
   533  				goids.append(int(ptr['goid']))
   534  		else:
   535  			goids = [int(gdb.parse_and_eval(goid_str))]
   536  
   537  		for goid in goids:
   538  			self.invoke_per_goid(goid, cmd)
   539  
   540  	def invoke_per_goid(self, goid, cmd):
   541  		pc, sp = find_goroutine(goid)
   542  		if not pc:
   543  			print("No such goroutine: ", goid)
   544  			return
   545  		pc = pc_to_int(pc)
   546  		save_frame = gdb.selected_frame()
   547  		gdb.parse_and_eval('$save_sp = $sp')
   548  		gdb.parse_and_eval('$save_pc = $pc')
   549  		# In GDB, assignments to sp must be done from the
   550  		# top-most frame, so select frame 0 first.
   551  		gdb.execute('select-frame 0')
   552  		gdb.parse_and_eval('$sp = {0}'.format(str(sp)))
   553  		gdb.parse_and_eval('$pc = {0}'.format(str(pc)))
   554  		try:
   555  			gdb.execute(cmd)
   556  		finally:
   557  			# In GDB, assignments to sp must be done from the
   558  			# top-most frame, so select frame 0 first.
   559  			gdb.execute('select-frame 0')
   560  			gdb.parse_and_eval('$pc = $save_pc')
   561  			gdb.parse_and_eval('$sp = $save_sp')
   562  			save_frame.select()
   563  
   564  
   565  class GoIfaceCmd(gdb.Command):
   566  	"Print Static and dynamic interface types"
   567  
   568  	def __init__(self):
   569  		gdb.Command.__init__(self, "iface", gdb.COMMAND_DATA, gdb.COMPLETE_SYMBOL)
   570  
   571  	def invoke(self, arg, _from_tty):
   572  		for obj in gdb.string_to_argv(arg):
   573  			try:
   574  				#TODO fix quoting for qualified variable names
   575  				obj = gdb.parse_and_eval(str(obj))
   576  			except Exception as e:
   577  				print("Can't parse ", obj, ": ", e)
   578  				continue
   579  
   580  			if obj['data'] == 0:
   581  				dtype = "nil"
   582  			else:
   583  				dtype = iface_dtype(obj)
   584  
   585  			if dtype is None:
   586  				print("Not an interface: ", obj.type)
   587  				continue
   588  
   589  			print("{0}: {1}".format(obj.type, dtype))
   590  
   591  # TODO: print interface's methods and dynamic type's func pointers thereof.
   592  #rsc: "to find the number of entries in the itab's Fn field look at
   593  # itab.inter->numMethods
   594  # i am sure i have the names wrong but look at the interface type
   595  # and its method count"
   596  # so Itype will start with a commontype which has kind = interface
   597  
   598  #
   599  # Register all convenience functions and CLI commands
   600  #
   601  GoLenFunc()
   602  GoCapFunc()
   603  DTypeFunc()
   604  GoroutinesCmd()
   605  GoroutineCmd()
   606  GoIfaceCmd()
   607  

View as plain text