Update from https://crrev.com/309415

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 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, os.pardir, os.pardir)
 ANDROID_BUILD_TOP = CHROME_SRC
 SYMBOLS_DIR = CHROME_SRC
 CHROME_SYMBOLS_DIR = CHROME_SRC
 
 ARCH = "arm"
 
 TOOLCHAIN_INFO = None
 
 def Uname():
   """'uname' for constructing prebuilt/<...> and out/host/<...> paths."""
@@ skipping 16 matching lines @@
     toolchain_prefix = "arm-linux-androideabi"
     ndk = "ndk"
   elif ARCH == "arm64":
     toolchain_source = "aarch64-linux-android-4.9"
     toolchain_prefix = "aarch64-linux-android"
     ndk = "ndk"
   elif ARCH == "x86":
     toolchain_source = "x86-4.9"
     toolchain_prefix = "i686-linux-android"
     ndk = "ndk"
-  elif ARCH == "x86_64" or ARCH == "x64":
+  elif ARCH == "x86_64":
     toolchain_source = "x86_64-4.9"
     toolchain_prefix = "x86_64-linux-android"
     ndk = "ndk"
   elif ARCH == "mips":
     toolchain_source = "mipsel-linux-android-4.9"
     toolchain_prefix = "mipsel-linux-android"
     ndk = "ndk"
   else:
     raise Exception("Could not find tool chain")
 
@@ skipping 25 matching lines @@
       ("aarch64-linux-android-" + gcc_version, "aarch64", "aarch64-linux-android")
     ]
   elif ARCH == "arm":
     known_toolchains = [
       ("arm-linux-androideabi-" + gcc_version, "arm", "arm-linux-androideabi")
     ]
   elif ARCH =="x86":
     known_toolchains = [
       ("x86-" + gcc_version, "x86", "i686-linux-android")
     ]
-  elif ARCH =="x86_64" or ARCH =="x64":
+  elif ARCH =="x86_64":
     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 = []
 
@@ skipping 53 matching lines @@
      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 ]
 
-def GetCandidates(filepart, candidate_fun, relative_dirs=None):
+def GetCandidates(dirs, filepart, candidate_fun):
   """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.
-    relative_dirs: a list of relative directory names to search from.
 
   Returns:
     A list of candidate files ordered by modification time, newest first.
   """
-  candidates = [CHROME_SYMBOLS_DIR]
+  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' ]
 
-  # Add the two possible mojo outdirs.
-  out_dir = os.path.join(CHROME_SYMBOLS_DIR, 'out')
-  candidates += PathListJoin([out_dir], ['android_Debug', 'android_Release'])
-
-  if relative_dirs:
-    candidates = PathListJoin(candidates, relative_dirs)
-
+  candidates = PathListJoin([out_dir], buildtype_list) + [CHROME_SYMBOLS_DIR]
+  candidates = PathListJoin(candidates, dirs)
   candidates = PathListJoin(candidates, [filepart])
   candidates = list(
       itertools.chain.from_iterable(map(candidate_fun, candidates)))
   candidates = sorted(candidates, key=os.path.getmtime, reverse=True)
+  # candidates = ['/usr/local/google/home/qsr/programmes/mojo/src/out/android_Debug/libmojo_shell.so']
   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('*.apk', glob.glob, relative_dirs=['apks'])
+  return GetCandidates(['apks'], '*.apk', glob.glob)
 
 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 39 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(
-      library_name,
+      ['', 'lib', 'lib.target'], library_name,
       lambda filename: filter(os.path.exists, [filename]))
 
-def TranslatePathFromDeviceToLocal(lib):
-  """Maps a path as seen on the device to a path on the local file system
-  containing symbols.
-
-  Args:
-    lib: library (or executable) pathname from device.
-  """
-
-  # SymbolInformation(lib, addr) receives lib that is either a basename or
-  # 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.
+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
 
   candidate_libraries = GetCandidateLibraries(library_name)
-  return (candidate_libraries[0] if candidate_libraries else
-      os.path.join(SYMBOLS_DIR, lib))
+  if not candidate_libraries:
+    return lib
+
+  library_path = os.path.relpath(candidate_libraries[0], SYMBOLS_DIR)
+  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:
     A list of the form [(source_symbol, source_location,
     object_symbol_with_offset)].
 
     If the function has been inlined then the list may contain
     more than one element with the symbols for the most deeply
     nested inlined location appearing first.  The list is
     always non-empty, even if no information is available.
 
     Usually you want to display the source_location and
     object_symbol_with_offset from the last element in the list.
   """
-  lib = TranslatePathFromDeviceToLocal(lib)
+  lib = TranslateLibPath(lib)
   info = SymbolInformationForSet(lib, set([addr]), get_detailed_info)
   return (info and info.get(addr)) or [(None, None, None)]
 
 
 def SymbolInformationForSet(lib, unique_addrs, get_detailed_info):
   """Look up symbol information for a set of addresses from the given library.
 
   Args:
     lib: library (or executable) pathname containing symbols
     unique_addrs: set of hexidecimal addresses
@@ skipping 70 matching lines @@
 
   Returns:
     A dictionary of the form {addr: [(symbol, file:line)]} where
     each address has a list of associated symbols and locations
     or an empty list if no symbol information was found.
 
     If the function has been inlined then the list may contain
     more than one element with the symbols for the most deeply
     nested inlined location appearing first.
   """
-  if not lib or not os.path.isfile(lib):
+  if not lib:
+    return None
+
+
+  symbols = SYMBOLS_DIR + lib
+  if not os.path.isfile(symbols):
     return None
 
   (label, platform, target) = FindToolchain()
   cmd = [ToolPath("addr2line"), "--functions", "--inlines",
-         "--demangle", "--exe=" + lib]
+      "--demangle", "--exe=" + symbols]
   child = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE)
 
   result = {}
   addrs = sorted(unique_addrs)
   for addr in addrs:
     child.stdin.write("0x%s\n" % addr)
     child.stdin.flush()
     records = []
     first = True
     while True:
@@ skipping 121 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)