Make it easier to debug failed symbolization

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 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
@@ skipping 167 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 54 matching lines @@
 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)
     if mapping:
       library_name = mapping
 
+  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)