Fix stack tool for library in apk crashes

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
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
 """Module for looking up symbolic debugging information.
 
 The information can include symbol names, offsets, and source locations.
 """
 
 import glob
 import itertools
+import logging
 import os
 import re
+import struct
 import subprocess
 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
 
 ARCH = "arm"
 
 TOOLCHAIN_INFO = None
 
+# See:
+# http://bugs.python.org/issue14315
+# https://hg.python.org/cpython/rev/6dd5e9556a60#l2.8
+def PatchZipFile():
+  oldDecodeExtra = zipfile.ZipInfo._decodeExtra
+  def decodeExtra(self):
+    try:
+      oldDecodeExtra(self)
+    except struct.error:
+      pass
+  zipfile.ZipInfo._decodeExtra = decodeExtra
+PatchZipFile()
+
 def Uname():
   """'uname' for constructing prebuilt/<...> and out/host/<...> paths."""
   uname = os.uname()[0]
   if uname == "Darwin":
     proc = os.uname()[-1]
     if proc == "i386" or proc == "x86_64":
       return "darwin-x86"
     return "darwin-ppc"
   if uname == "Linux":
     return "linux-x86"
@@ skipping 65 matching lines @@
     known_toolchains = [
       ("x86_64-" + gcc_version, "x86_64", "x86_64-linux-android")
     ]
   elif ARCH == "mips":
     known_toolchains = [
       ("mipsel-linux-android-" + gcc_version, "mips", "mipsel-linux-android")
     ]
   else:
     known_toolchains = []
 
+  logging.debug('FindToolcahin: known_toolchains=%s' % known_toolchains)
   # Look for addr2line to check for valid toolchain path.
   for (label, platform, target) in known_toolchains:
     toolchain_info = (label, platform, target);
     if os.path.exists(ToolPath("addr2line", toolchain_info)):
       TOOLCHAIN_INFO = toolchain_info
       print "Using toolchain from :" + ToolPath("", TOOLCHAIN_INFO)
       return toolchain_info
 
   raise Exception("Could not find tool chain")
 
@@ skipping 65 matching lines @@
   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])
+  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)
   return candidates
 
 def GetCandidateApks():
   """Returns a list of APKs which could contain the library.
 
   Args:
     None
@@ skipping 11 matching lines @@
 
   Returns:
     Name of the first library which would be crazy loaded from this APK.
   """
   zip_file = zipfile.ZipFile(apk_filename, 'r')
   for filename in zip_file.namelist():
     match = re.match('lib/[^/]*/crazy.(lib.*[.]so)', filename)
     if match:
       return match.group(1)
 
-def GetMatchingApks(device_apk_name):
+def GetApkFromLibrary(device_library_path):
+  match = re.match('.*/([^/]*)-[0-9]+[.]apk$', device_library_path)
+  if not match:
+    match = re.match('.*/([^/]*)-[0-9]+\/[^/]*\.apk$', device_library_path)

[rmcilroy, 2015/03/12 21:50:14]

Could you put some comments with examples for what these regexps are trying to
match against.  Any chance we can merge the regexps (if it's not super easy then
don't bother).

+    if not match:
+      return None
+  return match.group(1)
+
+def GetMatchingApks(package_name):
   """Find any APKs which match the package indicated by the device_apk_name.
 
   Args:
      device_apk_name: name of the APK on the device.
 
   Returns:
      A list of APK filenames which could contain the desired library.
   """
-  match = re.match('(.*)-[0-9]+[.]apk$', device_apk_name)
-  if not match:
-    return None
-  package_name = match.group(1)
   return filter(
       lambda candidate_apk:
           ApkMatchPackageName(GetAapt(), candidate_apk, package_name),
       GetCandidateApks())
 
 def MapDeviceApkToLibrary(device_apk_name):
   """Provide a library name which corresponds with device_apk_name.
 
   Args:
     device_apk_name: name of the APK on the device.
 
   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 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.
   """
   return GetCandidates(
-      ['lib', 'lib.target'], library_name,
+      ['lib', 'lib.target', '.'], library_name,
       lambda filename: filter(os.path.exists, [filename]))
 
 def TranslateLibPath(lib):
-  # SymbolInformation(lib, addr) receives lib as the path from symbols
-  # root to the symbols file. This needs to be translated to point to the
-  # correct .so path. If the user doesn't explicitly specify which directory to
-  # use, then use the most recently updated one in one of the known directories.
-  # If the .so is not found somewhere in CHROME_SYMBOLS_DIR, leave it
-  # untranslated in case it is an Android symbol in SYMBOLS_DIR.
-  library_name = os.path.basename(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.
-  if re.search('-[0-9]+[.]apk$', library_name):
-    mapping = MapDeviceApkToLibrary(library_name)
+  apk = GetApkFromLibrary(lib)
+  if apk is not None:
+    logging.debug('TranslateLibPath: apk=%s' % apk)
+    mapping = MapDeviceApkToLibrary(apk)
     if mapping:
-      library_name = mapping
+      lib = mapping
+
+  # SymbolInformation(lib, addr) receives lib as the path from symbols
+  # root to the symbols file. This needs to be translated to point to the
+  # correct .so path. If the user doesn't explicitly specify which directory to
+  # use, then use the most recently updated one in one of the known directories.
+  # If the .so is not found somewhere in CHROME_SYMBOLS_DIR, leave it
+  # untranslated in case it is an Android symbol in SYMBOLS_DIR.
+  library_name = os.path.basename(lib)
+
+  logging.debug('TranslateLibPath: lib=%s library_name=%s' % (lib, library_name))
 
   candidate_libraries = GetCandidateLibraries(library_name)
+  logging.debug('TranslateLibPath: candidate_libraries=%s' % candidate_libraries)
   if not candidate_libraries:
     return lib
 
   library_path = os.path.relpath(candidate_libraries[0], SYMBOLS_DIR)
+  logging.debug('TranslateLibPath: library_path=%s' % library_path)
   return '/' + library_path
 
 def SymbolInformation(lib, addr, get_detailed_info):
   """Look up symbol information about an address.
 
   Args:
     lib: library (or executable) pathname containing symbols
     addr: string hexidecimal address
 
   Returns:
@@ skipping 244 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)