Turn components/crash into a layered component.

components/crash/tools/generate_breakpad_symbols.py

-#!/usr/bin/env python
-# Copyright 2013 The Chromium Authors. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-"""A tool to generate symbols for a binary suitable for breakpad.
-
-Currently, the tool only supports Linux, Android, and Mac. Support for other
-platforms is planned.
-"""
-
-import errno
-import optparse
-import os
-import Queue
-import re
-import shutil
-import subprocess
-import sys
-import threading
-
-
-CONCURRENT_TASKS=4
-
-
-def GetCommandOutput(command):
-  """Runs the command list, returning its output.
-
-  Prints the given command (which should be a list of one or more strings),
-  then runs it and returns its output (stdout) as a string.
-
-  From chromium_utils.
-  """
-  devnull = open(os.devnull, 'w')
-  proc = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=devnull,
-                          bufsize=1)
-  output = proc.communicate()[0]
-  return output
-
-
-def GetDumpSymsBinary(build_dir=None):
-  """Returns the path to the dump_syms binary."""
-  DUMP_SYMS = 'dump_syms'
-  dump_syms_bin = os.path.join(os.path.expanduser(build_dir), DUMP_SYMS)
-  if not os.access(dump_syms_bin, os.X_OK):
-    print 'Cannot find %s.' % dump_syms_bin
-    return None
-
-  return dump_syms_bin
-
-
-def Resolve(path, exe_path, loader_path, rpaths):
-  """Resolve a dyld path.
-
-  @executable_path is replaced with |exe_path|
-  @loader_path is replaced with |loader_path|
-  @rpath is replaced with the first path in |rpaths| where the referenced file
-      is found
-  """
-  path = path.replace('@loader_path', loader_path)
-  path = path.replace('@executable_path', exe_path)
-  if path.find('@rpath') != -1:
-    for rpath in rpaths:
-      new_path = Resolve(path.replace('@rpath', rpath), exe_path, loader_path,
-                         [])
-      if os.access(new_path, os.X_OK):
-        return new_path
-    return ''
-  return path
-
-
-def GetSharedLibraryDependenciesLinux(binary):
-  """Return absolute paths to all shared library dependecies of the binary.
-
-  This implementation assumes that we're running on a Linux system."""
-  ldd = GetCommandOutput(['ldd', binary])
-  lib_re = re.compile('\t.* => (.+) \(.*\)$')
-  result = []
-  for line in ldd.splitlines():
-    m = lib_re.match(line)
-    if m:
-      result.append(m.group(1))
-  return result
-
-
-def GetSharedLibraryDependenciesMac(binary, exe_path):
-  """Return absolute paths to all shared library dependecies of the binary.
-
-  This implementation assumes that we're running on a Mac system."""
-  loader_path = os.path.dirname(binary)
-  otool = GetCommandOutput(['otool', '-l', binary]).splitlines()
-  rpaths = []
-  for idx, line in enumerate(otool):
-    if line.find('cmd LC_RPATH') != -1:
-      m = re.match(' *path (.*) \(offset .*\)$', otool[idx+2])
-      rpaths.append(m.group(1))
-
-  otool = GetCommandOutput(['otool', '-L', binary]).splitlines()
-  lib_re = re.compile('\t(.*) \(compatibility .*\)$')
-  deps = []
-  for line in otool:
-    m = lib_re.match(line)
-    if m:
-      dep = Resolve(m.group(1), exe_path, loader_path, rpaths)
-      if dep:
-        deps.append(os.path.normpath(dep))
-  return deps
-
-
-def GetSharedLibraryDependencies(options, binary, exe_path):
-  """Return absolute paths to all shared library dependecies of the binary."""
-  deps = []
-  if sys.platform.startswith('linux'):
-    deps = GetSharedLibraryDependenciesLinux(binary)
-  elif sys.platform == 'darwin':
-    deps = GetSharedLibraryDependenciesMac(binary, exe_path)
-  else:
-    print "Platform not supported."
-    sys.exit(1)
-
-  result = []
-  build_dir = os.path.abspath(options.build_dir)
-  for dep in deps:
-    if (os.access(dep, os.X_OK) and
-        os.path.abspath(os.path.dirname(dep)).startswith(build_dir)):
-      result.append(dep)
-  return result
-
-
-def mkdir_p(path):
-  """Simulates mkdir -p."""
-  try:
-    os.makedirs(path)
-  except OSError as e:
-    if e.errno == errno.EEXIST and os.path.isdir(path):
-      pass
-    else: raise
-
-
-def GenerateSymbols(options, binaries):
-  """Dumps the symbols of binary and places them in the given directory."""
-
-  queue = Queue.Queue()
-  print_lock = threading.Lock()
-
-  def _Worker():
-    while True:
-      binary = queue.get()
-
-      should_dump_syms = True
-      reason = "no reason"
-
-      output_path = os.path.join(
-          options.symbols_dir, os.path.basename(binary))
-      if os.path.isdir(output_path):
-        if os.path.getmtime(binary) < os.path.getmtime(output_path):
-          should_dump_syms = False
-          reason = "symbols are more current than binary"
-
-      if not should_dump_syms:
-        if options.verbose:
-          with print_lock:
-            print "Skipping %s (%s)" % (binary, reason)
-        queue.task_done()
-        continue
-
-      if options.verbose:
-        with print_lock:
-          print "Generating symbols for %s" % binary
-
-      if os.path.isdir(output_path):
-        os.utime(output_path, None)
-
-      syms = GetCommandOutput([GetDumpSymsBinary(options.build_dir), '-r',
-                               binary])
-      module_line = re.match("MODULE [^ ]+ [^ ]+ ([0-9A-F]+) (.*)\n", syms)
-      output_path = os.path.join(options.symbols_dir, module_line.group(2),
-                                 module_line.group(1))
-      mkdir_p(output_path)
-      symbol_file = "%s.sym" % module_line.group(2)
-      try:
-        f = open(os.path.join(output_path, symbol_file), 'w')
-        f.write(syms)
-        f.close()
-      except Exception, e:
-        # Not much we can do about this.
-        with print_lock:
-          print e
-
-      queue.task_done()
-
-  for binary in binaries:
-    queue.put(binary)
-
-  for _ in range(options.jobs):
-    t = threading.Thread(target=_Worker)
-    t.daemon = True
-    t.start()
-
-  queue.join()
-
-
-def main():
-  parser = optparse.OptionParser()
-  parser.add_option('', '--build-dir', default='',
-                    help='The build output directory.')
-  parser.add_option('', '--symbols-dir', default='',
-                    help='The directory where to write the symbols file.')
-  parser.add_option('', '--binary', default='',
-                    help='The path of the binary to generate symbols for.')
-  parser.add_option('', '--clear', default=False, action='store_true',
-                    help='Clear the symbols directory before writing new '
-                         'symbols.')
-  parser.add_option('-j', '--jobs', default=CONCURRENT_TASKS, action='store',
-                    type='int', help='Number of parallel tasks to run.')
-  parser.add_option('-v', '--verbose', action='store_true',
-                    help='Print verbose status output.')
-
-  (options, _) = parser.parse_args()
-
-  if not options.symbols_dir:
-    print "Required option --symbols-dir missing."
-    return 1
-
-  if not options.build_dir:
-    print "Required option --build-dir missing."
-    return 1
-
-  if not options.binary:
-    print "Required option --binary missing."
-    return 1
-
-  if not os.access(options.binary, os.X_OK):
-    print "Cannot find %s." % options.binary
-    return 1
-
-  if options.clear:
-    try:
-      shutil.rmtree(options.symbols_dir)
-    except:
-      pass
-
-  if not GetDumpSymsBinary(options.build_dir):
-    return 1
-
-  # Build the transitive closure of all dependencies.
-  binaries = set([options.binary])
-  queue = [options.binary]
-  exe_path = os.path.dirname(options.binary)
-  while queue:
-    deps = GetSharedLibraryDependencies(options, queue.pop(0), exe_path)
-    new_deps = set(deps) - binaries
-    binaries |= new_deps
-    queue.extend(list(new_deps))
-
-  GenerateSymbols(options, binaries)
-
-  return 0
-
-
-if '__main__' == __name__:
-  sys.exit(main())