| # Copyright 2016 The Fuchsia Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """Initialize gdb for debugging Fuchsia code.""" |
| |
| import gdb |
| import glob |
| import os |
| |
| |
| # Extract the GDB version number so scripts can easily examine it. |
| # We export four variables: |
| # GDB_MAJOR_VERSION, GDB_MINOR_VERSION, GDB_PATCH_VERSION, GDB_GOOGLE_VERSION. |
| # The first three are standard, e.g. 7.10.1. |
| # GDB_GOOGLE_VERSION is the N in "-gfN" Fuchsia releases. |
| # A value of zero means this isn't a Google Fuchsia gdb. |
| _GDB_DASH_VERSION = gdb.VERSION.split("-") |
| _GDB_DOT_VERSION = _GDB_DASH_VERSION[0].split(".") |
| GDB_MAJOR_VERSION = int(_GDB_DOT_VERSION[0]) |
| GDB_MINOR_VERSION = int(_GDB_DOT_VERSION[1]) |
| if len(_GDB_DOT_VERSION) >= 3: |
| GDB_PATCH_VERSION = int(_GDB_DOT_VERSION[2]) |
| else: |
| GDB_PATCH_VERSION = 0 |
| GDB_GOOGLE_VERSION = 0 |
| if len(_GDB_DASH_VERSION) >= 2: |
| if _GDB_DASH_VERSION[1].startswith("gf"): |
| try: |
| GDB_GOOGLE_VERSION = int(_GDB_DASH_VERSION[1][2:]) |
| except ValueError: |
| pass |
| |
| # The top level zircon build directory |
| _TOP_ZIRCON_BUILD_DIR = "out/build-zircon" |
| |
| # Prefix of zircon build directories within _TOP_ZIRCON_BUILD_DIR. |
| _ZIRCON_BUILD_SUBDIR_PREFIX = "build" |
| |
| # True if fuchsia support has been initialized. |
| _INITIALIZED_FUCHSIA_SUPPORT = False |
| |
| # The prefix for fuchsia commands. |
| _FUCHSIA_COMMAND_PREFIX = "fuchsia" |
| |
| |
| class _FuchsiaPrefix(gdb.Command): |
| """Prefix command for Fuchsia-specific commands.""" |
| |
| def __init__(self): |
| super(_FuchsiaPrefix, self).__init__( |
| _FUCHSIA_COMMAND_PREFIX, gdb.COMMAND_USER, prefix=True) |
| |
| |
| class _FuchsiaSetPrefix(gdb.Command): |
| """Prefix "set" command for Fuchsia parameters.""" |
| |
| def __init__(self): |
| super(_FuchsiaSetPrefix, self).__init__( |
| "set %s" % (_FUCHSIA_COMMAND_PREFIX), gdb.COMMAND_USER, |
| prefix=True) |
| |
| |
| class _FuchsiaShowPrefix(gdb.Command): |
| """Prefix "show" command for Fuchsia parameters.""" |
| |
| def __init__(self): |
| super(_FuchsiaShowPrefix, self).__init__( |
| "show %s" % (_FUCHSIA_COMMAND_PREFIX), gdb.COMMAND_USER, |
| prefix=True) |
| |
| def invoke(self, from_tty): |
| # TODO(dje): Show all the parameters, a la cmd_show_list. |
| pass |
| |
| |
| class _FuchsiaVerbosity(gdb.Parameter): |
| """Verbosity for Fuchsia gdb support. |
| |
| There are four levels of verbosity: |
| 0 = off |
| 1 = minimal |
| 2 = what a typical user might want to see |
| 3 = everything, intended for maintainers only |
| """ |
| # Note: While not every verbosity level is exercised today, these levels |
| # are convention in Google's internal gdb. |
| |
| set_doc = "Set level of Fuchsia verbosity." |
| show_doc = "Show level of Fuchsia verbosity." |
| |
| def __init__(self): |
| super(_FuchsiaVerbosity, self).__init__( |
| "%s verbosity" % (_FUCHSIA_COMMAND_PREFIX), |
| gdb.COMMAND_FILES, gdb.PARAM_ZINTEGER) |
| # Default to basic informational messages to help users know |
| # what's going on. |
| self.value = 1 |
| |
| def get_show_string(self, pvalue): |
| return "Fuchsia verbosity is " + pvalue + "." |
| |
| def get_set_string(self): |
| # Ugh. There doesn't seem to be a way to implement a gdb parameter in |
| # Python that will be silent when the user changes the value. |
| return "Fuchsia verbosity been set to %d." % (self.value) |
| |
| |
| def _IsFuchsiaFile(objfile): |
| """Return True if objfile is a Fuchsia file.""" |
| # TODO(dje): Not sure how to effectively achieve this. |
| # Assume we're always debugging a Fuchsia program for now. |
| # If the user wants to debug native programs, s/he can use native gdb. |
| return True |
| |
| |
| def _ClearObjfilesHandler(event): |
| """Reset debug information tracking when all objfiles are unloaded.""" |
| event.progspace.seen_exec = False |
| |
| |
| def _FindSysroot(arch): |
| """Return the path to the sysroot for arch.""" |
| if arch == "x64": |
| suffix = "-x64" |
| elif arch == "arm64": |
| suffix = "-arm64" |
| else: |
| assert(False) |
| print ("TRYING: %s/%s*%s" % ( |
| _TOP_ZIRCON_BUILD_DIR, _ZIRCON_BUILD_SUBDIR_PREFIX, suffix)) |
| for filename in glob.iglob("%s/%s*%s" % ( |
| _TOP_ZIRCON_BUILD_DIR, _ZIRCON_BUILD_SUBDIR_PREFIX, suffix)): |
| return "%s/sysroot" % (filename) |
| return None |
| |
| |
| def _NewObjfileHandler(event): |
| """Handle new objfiles being loaded.""" |
| # TODO(dje): Use this hook to automagically fetch debug info. |
| |
| verbosity = gdb.parameter( |
| "%s verbosity" % (_FUCHSIA_COMMAND_PREFIX)) |
| if verbosity >= 3: |
| print "Hi, I'm the new_objfile event handler." |
| |
| objfile = event.new_objfile |
| progspace = objfile.progspace |
| # Assume the first objfile we see is the main executable. |
| # There's nothing else we can do at this point. |
| seen_exec = hasattr(progspace, "seen_exec") and progspace.seen_exec |
| |
| # Early exit if nothing to do. |
| # We don't handle multiple arches so we KISS. |
| if seen_exec: |
| if verbosity >= 3: |
| print "Already seen exec, ignoring: %s" % (basename) |
| return |
| progspace.seen_exec = True |
| |
| filename = objfile.username |
| basename = os.path.basename(filename) |
| if objfile.owner is not None: |
| if verbosity >= 3: |
| print "Separate debug file, ignoring: %s" % (basename) |
| return |
| |
| # If we're debugging a native executable, unset the solib search path. |
| if not _IsFuchsiaFile(objfile): |
| if verbosity >= 3: |
| print "Debugging non-Fuchsia file: %s" % (basename) |
| print "Note: Unsetting solib-search-path." |
| gdb.execute("set solib-search-path") |
| return |
| |
| # The sysroot to use is dependent on the architecture of the program. |
| # This is needed to find ld.so debug info. |
| # TODO(dje): IWBN to not need ld.so debug info. |
| # TODO(dje): IWBN if objfiles exposed their arch field. |
| arch_string = gdb.execute("show arch", to_string=True) |
| if arch_string.find("arm64") >= 0: |
| # Alas there are different directories for different arm64 builds |
| # (qemu, rpi3, etc.). Pick something, hopefully this can go away soon. |
| sysroot_dir = _FindSysroot("arm64") |
| elif arch_string.find("x64") >= 0: |
| sysroot_dir = _FindSysroot("x64") |
| else: |
| print "WARNING: unsupported architecture\n%s" % (arch_string) |
| return |
| |
| # TODO(dje): We can't use sysroot to find ld.so.1 because it doesn't |
| # have a path on Fuchsia. Plus files in Fuchsia are intended to be |
| # "ephemeral" by nature. So we punt on setting sysroot for now, even |
| # though IWBN if we could use it. |
| if sysroot_dir: |
| solib_search_path = "%s/debug" % (sysroot_dir) |
| print "Note: Setting solib-search-path to %s" % (solib_search_path) |
| gdb.execute("set solib-search-path %s" % (solib_search_path)) |
| else: |
| print "WARNING: could not find sysroot directory" |
| |
| |
| def _InitializeFuchsiaObjfileTracking(): |
| # We *need* solib-search-path set so that we can find debug info for |
| # ld.so.1. Otherwise it's game over for a usable debug session: |
| # We won't be able to set a breakpoint at the dynamic linker breakpoint |
| # and we won't be able to relocate the program (all Fuchsia executables |
| # are PIE). However, we don't necessarily know which architecture we're |
| # debugging yet so we don't know which directory to set the search path |
| # to. To solve this we hook into the "new objfile" event. |
| # This event can also let us automagically fetch debug info for files |
| # as they're loaded (TODO(dje)). |
| gdb.events.clear_objfiles.connect(_ClearObjfilesHandler) |
| gdb.events.new_objfile.connect(_NewObjfileHandler) |
| |
| |
| class _SetFuchsiaDefaults(gdb.Command): |
| """Set GDB parameters to values useful for Fuchsia code. |
| |
| Usage: set-fuchsia-defaults |
| |
| These changes are made: |
| set non-stop on |
| set target-async on |
| set remotetimeout 10 |
| set sysroot # (set to empty path) |
| |
| Fuchsia gdbserver currently supports non-stop only (and even that support |
| is preliminary so heads up). |
| """ |
| |
| def __init__(self): |
| super(_SetFuchsiaDefaults, self).__init__( |
| "%s set-defaults" % (_FUCHSIA_COMMAND_PREFIX), |
| gdb.COMMAND_DATA) |
| |
| # The name and parameters of this function are defined by GDB. |
| # pylint: disable=invalid-name |
| # pylint: disable=unused-argument |
| def invoke(self, arg, from_tty): |
| """GDB calls this to perform the command.""" |
| # We don't need to tell the user about everything we do. |
| # But it's helpful to give a heads up for things s/he may trip over. |
| print "Note: Enabling non-stop, target-async." |
| gdb.execute("set non-stop on") |
| gdb.execute("set target-async on") |
| gdb.execute("set remotetimeout 10") |
| |
| # The default is "target:" which will cause gdb to fetch every dso, |
| # which is ok sometimes, but for right now it's a nuisance. |
| print "Note: Unsetting sysroot." |
| gdb.execute("set sysroot") |
| |
| |
| def _InstallFuchsiaCommands(): |
| # We don't do anything with the result, we just need to call |
| # the constructor. |
| _FuchsiaPrefix() |
| _FuchsiaSetPrefix() |
| _FuchsiaShowPrefix() |
| _FuchsiaVerbosity() |
| _SetFuchsiaDefaults() |
| |
| |
| def initialize(): |
| """Set up GDB for debugging Fuchsia code. |
| |
| This function is invoked via gdb's "system.gdbinit" |
| when it detects it is being started in a fuchsia tree. |
| |
| It is ok to call this function multiple times, but only the first |
| is effective. |
| |
| Returns: |
| Nothing. |
| """ |
| |
| global _INITIALIZED_FUCHSIA_SUPPORT |
| if _INITIALIZED_FUCHSIA_SUPPORT: |
| print "Fuchsia support already loaded." |
| return |
| _INITIALIZED_FUCHSIA_SUPPORT = True |
| |
| _InstallFuchsiaCommands() |
| _InitializeFuchsiaObjfileTracking() |
| print "Setting fuchsia defaults. 'help fuchsia set-defaults' for details." |
| gdb.execute("fuchsia set-defaults") |
