Android: Make stack tool work for GN builds

third_party/android_platform/development/scripts/symbol.py

 #!/usr/bin/python
 #
 # Copyright (C) 2013 The Android Open Source Project
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
@@ skipping 15 matching lines @@
 import re
 import struct
 import subprocess
 import sys
 import zipfile
 
 CHROME_SRC = os.path.join(os.path.realpath(os.path.dirname(__file__)),
                           os.pardir, os.pardir, os.pardir, os.pardir)
 ANDROID_BUILD_TOP = CHROME_SRC
 SYMBOLS_DIR = CHROME_SRC
-CHROME_SYMBOLS_DIR = CHROME_SRC
+CHROME_SYMBOLS_DIR = None
 
 ARCH = "arm"
 
 TOOLCHAIN_INFO = None
 
 sys.path.insert(0, os.path.join(CHROME_SRC, 'build', 'android'))
 from pylib.symbols import elf_symbolizer
 
 # See:
 # http://bugs.python.org/issue14315
@@ skipping 148 matching lines @@
 
    Args:
      prefix_list: list of path prefixes.
      suffix_list: list of path suffixes.
 
    Returns:
      List of paths each of which joins a prefix with a suffix.
    """
    return [
        os.path.join(prefix, suffix)
-       for prefix in prefix_list for suffix in suffix_list ]
+       for suffix in suffix_list for prefix in prefix_list ]
 
-def GetCandidates(dirs, filepart, candidate_fun):
+
+def _GetChromeOutputDirCandidates():

[johnme, 2015/10/20 15:40:20]

This could perhaps reuse existing logic:

sys.path.append(os.path.join(os.path.abspath(os.path.dirname(__file__)),'..',
'..', '..', '..', 'build', 'android'))
from pylib import constants

def _GetChromeOutputDirCandidates():
  if os.environ.get('CHROMIUM_OUTPUT_DIR') or os.environ.get('BUILDTYPE'):
    return [constants.GetOutDirectory()]
  return [constants.GetOutDirectory(build_type='Debug'),
          constants.GetOutDirectory(build_type='Release')]

[agrieve, 2015/10/20 18:24:27]

Done.

+  """Returns a list of output directories to look in."""
+  out_dir = os.environ.get('CHROMIUM_OUTPUT_DIR')
+  if out_dir:
+    return [out_dir]
+  out_dir = os.environ.get('CHROMIUM_OUT_DIR', 'out')
+  out_dir = os.path.join(CHROME_SRC, out_dir)
+  buildtype = os.environ.get('BUILDTYPE')
+  if buildtype:
+    buildtype_list = [ buildtype ]
+  else:
+    buildtype_list = [ 'Debug', 'Release' ]
+  return PathListJoin([out_dir], buildtype_list)
+
+
+def GetCandidates(dirs, filepart, candidate_fun, sort=True):
   """Returns a list of candidate filenames.
 
   Args:
     dirs: a list of the directory part of the pathname.
     filepart: the file part of the pathname.
     candidate_fun: a function to apply to each candidate, returns a list.
+    sort: Whether to sort by modification time (newest first).
 
   Returns:
-    A list of candidate files ordered by modification time, newest first.
+    A list of candidate files filtered by candidate_fun, in the order given.
   """
-  out_dir = os.environ.get('CHROMIUM_OUT_DIR', 'out')
-  out_dir = os.path.join(CHROME_SYMBOLS_DIR, out_dir)
-  buildtype = os.environ.get('BUILDTYPE')
-  if buildtype:
-    buildtype_list = [ buildtype ]
-  else:
-    buildtype_list = [ 'Debug', 'Release' ]
-
-  candidates = PathListJoin([out_dir], buildtype_list) + [CHROME_SYMBOLS_DIR]
-  candidates = PathListJoin(candidates, dirs)
-  candidates = PathListJoin(candidates, [filepart])
+  candidates = PathListJoin(dirs, [filepart])
   logging.debug('GetCandidates: prefiltered candidates = %s' % candidates)
   candidates = list(
       itertools.chain.from_iterable(map(candidate_fun, candidates)))
-  candidates = sorted(candidates, key=os.path.getmtime, reverse=True)
+  if sort:
+    candidates.sort(key=os.path.getmtime, reverse=True)
   return candidates
 
 def GetCandidateApks():
   """Returns a list of APKs which could contain the library.
 
   Args:
     None
 
   Returns:
     list of APK filename which could contain the library.
   """
-  return GetCandidates(['apks'], '*.apk', glob.glob)
+  dirs = PathListJoin(_GetChromeOutputDirCandidates(), ['apks'])
+  return GetCandidates(dirs, '*.apk', glob.glob, sort=True)
 
 def GetCrazyLib(apk_filename):
   """Returns the name of the first crazy library from this APK.
 
   Args:
     apk_filename: name of an APK file.
 
   Returns:
     Name of the first library which would be crazy loaded from this APK.
   """
@@ skipping 32 matching lines @@
   Returns:
     Name of the library which corresponds to that APK.
   """
   matching_apks = GetMatchingApks(device_apk_name)
   logging.debug('MapDeviceApkToLibrary: matching_apks=%s' % matching_apks)
   for matching_apk in matching_apks:
     crazy_lib = GetCrazyLib(matching_apk)
     if crazy_lib:
       return crazy_lib
 
+def GetLibrarySearchPaths():
+  if CHROME_SYMBOLS_DIR:
+    return [CHROME_SYMBOLS_DIR]
+  dirs = _GetChromeOutputDirCandidates()
+  return PathListJoin(dirs, ['lib.unstripped', 'lib', 'lib.target', '.'])
+
 def GetCandidateLibraries(library_name):
   """Returns a list of candidate library filenames.
 
   Args:
     library_name: basename of the library to match.
 
   Returns:
     A list of matching library filenames for library_name.
   """
+  # Sorting doens't work for native libraries because the stripped version is

[johnme, 2015/10/20 15:40:20]

doesn't

[agrieve, 2015/10/20 18:24:27]

Done.

+  # always newer than the unstripped version.

[johnme, 2015/10/20 15:40:20]

Hmm, but not sorting seems a risky way to get the unstripped version. Especially
since sorting by mtime seems to be the only way this auto-detects whether you
want Debug or Release (fragile though this is).

Why not add a prefer_unstripped parameter to GetCandidates, which just
partitions the candidates (after they are sorted by mtime) as follows:

# Move unstripped to front of list
candidates.sort(key=lambda c: 'unstripped' not in c)

[agrieve, 2015/10/20 18:24:27]

Like it. ;)

   return GetCandidates(
-      ['lib', 'lib.target', '.'], library_name,
-      lambda filename: filter(os.path.exists, [filename]))
+      GetLibrarySearchPaths(), library_name,
+      lambda filename: filter(os.path.exists, [filename]),
+      sort=False)
 
 def TranslateLibPath(lib):
   # The filename in the stack trace maybe an APK name rather than a library
   # name. This happens when the library was loaded directly from inside the
   # APK. If this is the case we try to figure out the library name by looking
   # for a matching APK file and finding the name of the library in contains.
   # The name of the APK file on the device is of the form
   # <package_name>-<number>.apk. The APK file on the host may have any name
   # so we look at the APK badging to see if the package name matches.
   apk = GetApkFromLibrary(lib)
@@ skipping 272 matching lines @@
   process.stdin.write("\n")
   process.stdin.close()
   demangled_symbol = process.stdout.readline().strip()
   process.stdout.close()
   return demangled_symbol
 
 def FormatSymbolWithOffset(symbol, offset):
   if offset == 0:
     return symbol
   return "%s+%d" % (symbol, offset)