# Copyright 2018 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.

from __future__ import print_function

import bisect
import collections
import logging
import os
import re

from pylib.constants import host_paths
from pylib.symbols import elf_symbolizer


def _AndroidAbiToCpuArch(android_abi):
  """Return the Chromium CPU architecture name for a given Android ABI."""
  _ARCH_MAP = {
    'armeabi': 'arm',
    'armeabi-v7a': 'arm',
    'arm64-v8a': 'arm64',
    'x86_64': 'x64',
  }
  return _ARCH_MAP.get(android_abi, android_abi)


def _HexAddressRegexpFor(android_abi):
  """Return a regexp matching hexadecimal addresses for a given Android ABI."""
  if android_abi in ['x86_64', 'arm64-v8a', 'mips64']:
    width = 16
  else:
    width = 8
  return '[0-9a-f]{%d}' % width


class HostLibraryFinder(object):
  """Translate device library path to matching host unstripped library path.

  Usage is the following:
    1) Create instance.
    2) Call AddSearchDir() once or more times to add host directory path to
       look for unstripped native libraries.
    3) Call Find(device_libpath) repeatedly to translate a device-specific
       library path into the corresponding host path to the unstripped
       version.
  """
  def __init__(self):
    """Initialize instance."""
    self._search_dirs = []
    self._lib_map = {}        # Map of library name to host file paths.

  def AddSearchDir(self, lib_dir):
    """Add a directory to the search path for host native shared libraries.

    Args:
      lib_dir: host path containing native libraries.
    """
    if not os.path.exists(lib_dir):
      logging.warning('Ignoring missing host library directory: %s', lib_dir)
      return
    if not os.path.isdir(lib_dir):
      logging.warning('Ignoring invalid host library directory: %s', lib_dir)
      return
    self._search_dirs.append(lib_dir)
    self._lib_map = {}  # Reset the map.

  def Find(self, device_libpath):
    """Find the host file path matching a specific device library path.

    Args:
      device_libpath: device-specific file path to library or executable.
    Returns:
      host file path to the unstripped version of the library, or None.
    """
    host_lib_path = None
    lib_name = os.path.basename(device_libpath)
    host_lib_path = self._lib_map.get(lib_name)
    if not host_lib_path:
      for search_dir in self._search_dirs:
        lib_path = os.path.join(search_dir, lib_name)
        if os.path.exists(lib_path):
          host_lib_path = lib_path
          break

      if not host_lib_path:
        logging.debug('Could not find host library for: %s', lib_name)
      self._lib_map[lib_name] = host_lib_path

    return host_lib_path


class SymbolResolver(object):
  """A base class for objets that can symbolize library (path, offset)
     pairs into symbol information strings. Usage is the following:

     1) Create new instance (by calling the constructor of a derived
        class, since this is only the base one).

     2) Call SetAndroidAbi() before any call to FindSymbolInfo() in order
        to set the Android CPU ABI used for symbolization.

     3) Before the first call to FindSymbolInfo(), one can call
        AddLibraryOffset(), or AddLibraryOffsets() to record a set of offsets
        that you will want to symbolize later through FindSymbolInfo(). Doing
        so allows some SymbolResolver derived classes to work faster (e.g. the
        one that invokes the 'addr2line' program, since the latter works faster
        if the offsets provided as inputs are sorted in increasing order).

     3) Call FindSymbolInfo(path, offset) to return the corresponding
        symbol information string, or None if this doesn't correspond
        to anything the instance can handle.

        Note that whether the path is specific to the device or to the
        host depends on the derived class implementation.
  """
  def __init__(self):
    self._android_abi = None
    self._lib_offsets_map = collections.defaultdict(set)

  def SetAndroidAbi(self, android_abi):
    """Set the Android ABI value for this instance.

    Calling this function before FindSymbolInfo() is required by some
    derived class implementations.

    Args:
      android_abi: Native Android CPU ABI name (e.g. 'armeabi-v7a').
    Raises:
      Exception if the ABI was already set with a different value.
    """
    if self._android_abi and self._android_abi != android_abi:
      raise Exception('Cannot reset Android ABI to new value %s, already set '
                      'to %s' % (android_abi, self._android_abi))

    self._android_abi = android_abi

  def AddLibraryOffset(self, lib_path, offset):
    """Associate a single offset to a given device library.

    This must be called before FindSymbolInfo(), otherwise its input arguments
    will be ignored.

    Args:
      lib_path: A library path.
      offset: An integer offset within the corresponding library that will be
        symbolized by future calls to FindSymbolInfo.
    """
    self._lib_offsets_map[lib_path].add(offset)

  def AddLibraryOffsets(self, lib_path, lib_offsets):
    """Associate a set of wanted offsets to a given device library.

    This must be called before FindSymbolInfo(), otherwise its input arguments
    will be ignored.

    Args:
      lib_path: A library path.
      lib_offsets: An iterable of integer offsets within the corresponding
        library that will be symbolized by future calls to FindSymbolInfo.
    """
    self._lib_offsets_map[lib_path].update(lib_offsets)

  # pylint: disable=unused-argument,no-self-use
  def FindSymbolInfo(self, lib_path, lib_offset):
    """Symbolize a device library path and offset.

    Args:
      lib_path: Library path (device or host specific, depending on the
        derived class implementation).
      lib_offset: Integer offset within the library.
    Returns:
      Corresponding symbol information string, or None.
    """
    # The base implementation cannot symbolize anything.
    return None
  # pylint: enable=unused-argument,no-self-use


class ElfSymbolResolver(SymbolResolver):
  """A SymbolResolver that can symbolize host path + offset values using
     an elf_symbolizer.ELFSymbolizer instance.
  """
  def __init__(self, addr2line_path_for_tests=None):
    super(ElfSymbolResolver, self).__init__()
    self._addr2line_path = addr2line_path_for_tests

    # Used to cache one ELFSymbolizer instance per library path.
    self._elf_symbolizer_cache = {}

    # Used to cache FindSymbolInfo() results. Maps host library paths
    # to (offset -> symbol info string) dictionaries.
    self._symbol_info_cache = collections.defaultdict(dict)
    self._allow_symbolizer = True

  def _CreateSymbolizerFor(self, host_path):
    """Create the ELFSymbolizer instance associated with a given lib path."""
    addr2line_path = self._addr2line_path
    if not addr2line_path:
      if not self._android_abi:
        raise Exception(
            'Android CPU ABI must be set before calling FindSymbolInfo!')

      cpu_arch = _AndroidAbiToCpuArch(self._android_abi)
      self._addr2line_path = host_paths.ToolPath('addr2line', cpu_arch)

    return elf_symbolizer.ELFSymbolizer(
        elf_file_path=host_path, addr2line_path=self._addr2line_path,
        callback=ElfSymbolResolver._Callback, inlines=True)

  def DisallowSymbolizerForTesting(self):
    """Disallow FindSymbolInfo() from using a symbolizer.

    This is used during unit-testing to ensure that the offsets that were
    recorded via AddLibraryOffset()/AddLibraryOffsets() are properly
    symbolized, but not anything else.
    """
    self._allow_symbolizer = False

  def FindSymbolInfo(self, host_path, offset):
    """Override SymbolResolver.FindSymbolInfo.

    Args:
      host_path: Host-specific path to the native shared library.
      offset: Integer offset within the native library.
    Returns:
      A symbol info string, or None.
    """
    offset_map = self._symbol_info_cache[host_path]
    symbol_info = offset_map.get(offset)
    if symbol_info:
      return symbol_info

    # Create symbolizer on demand.
    symbolizer = self._elf_symbolizer_cache.get(host_path)
    if not symbolizer:
      symbolizer = self._CreateSymbolizerFor(host_path)
      self._elf_symbolizer_cache[host_path] = symbolizer

      # If there are pre-recorded offsets for this path, symbolize them now.
      offsets = self._lib_offsets_map.get(host_path)
      if offsets:
        offset_map = {}
        for pre_offset in offsets:
          symbolizer.SymbolizeAsync(
              pre_offset, callback_arg=(offset_map, pre_offset))
        symbolizer.WaitForIdle()
        self._symbol_info_cache[host_path] = offset_map

        symbol_info = offset_map.get(offset)
        if symbol_info:
          return symbol_info

    if not self._allow_symbolizer:
      return None

    # Symbolize single offset. Slower if addresses are not provided in
    # increasing order to addr2line.
    symbolizer.SymbolizeAsync(offset,
                              callback_arg=(offset_map, offset))
    symbolizer.WaitForIdle()
    return offset_map.get(offset)

  @staticmethod
  def _Callback(sym_info, callback_arg):
    offset_map, offset = callback_arg
    offset_map[offset] = str(sym_info)


class DeviceSymbolResolver(SymbolResolver):
  """A SymbolResolver instance that accepts device-specific path.

  Usage is the following:
    1) Create new instance, passing a parent SymbolResolver instance that
       accepts host-specific paths, and a HostLibraryFinder instance.

    2) Optional: call AddApkOffsets() to add offsets from within an APK
       that contains uncompressed native shared libraries.

    3) Use it as any SymbolResolver instance.
  """
  def __init__(self, host_resolver, host_lib_finder):
    """Initialize instance.

    Args:
      host_resolver: A parent SymbolResolver instance that will be used
        to resolve symbols from host library paths.
      host_lib_finder: A HostLibraryFinder instance used to locate
        unstripped libraries on the host.
    """
    super(DeviceSymbolResolver, self).__init__()
    self._host_lib_finder = host_lib_finder
    self._bad_device_lib_paths = set()
    self._host_resolver = host_resolver

  def SetAndroidAbi(self, android_abi):
    super(DeviceSymbolResolver, self).SetAndroidAbi(android_abi)
    self._host_resolver.SetAndroidAbi(android_abi)

  def AddLibraryOffsets(self, device_lib_path, lib_offsets):
    """Associate a set of wanted offsets to a given device library.

    This must be called before FindSymbolInfo(), otherwise its input arguments
    will be ignored.

    Args:
      device_lib_path: A device-specific library path.
      lib_offsets: An iterable of integer offsets within the corresponding
        library that will be symbolized by future calls to FindSymbolInfo.
        want to symbolize.
    """
    if device_lib_path in self._bad_device_lib_paths:
      return

    host_lib_path = self._host_lib_finder.Find(device_lib_path)
    if not host_lib_path:
      # NOTE: self._bad_device_lib_paths is only used to only print this
      #       warning once per bad library.
      logging.warning('Could not find host library matching device path: %s',
                      device_lib_path)
      self._bad_device_lib_paths.add(device_lib_path)
      return

    self._host_resolver.AddLibraryOffsets(host_lib_path, lib_offsets)

  def AddApkOffsets(self, device_apk_path, apk_offsets, apk_translator):
    """Associate a set of wanted offsets to a given device APK path.

    This converts the APK-relative offsets into offsets relative to the
    uncompressed libraries it contains, then calls AddLibraryOffsets()
    for each one of the libraries.

    Must be called before FindSymbolInfo() as well, otherwise input arguments
    will be ignored.

    Args:
      device_apk_path: Device-specific APK path.
      apk_offsets: Iterable of offsets within the APK file.
      apk_translator: An ApkLibraryPathTranslator instance used to extract
        library paths from the APK.
    """
    libraries_map = collections.defaultdict(set)
    for offset in apk_offsets:
      lib_path, lib_offset = apk_translator.TranslatePath(device_apk_path,
                                                          offset)
      libraries_map[lib_path].add(lib_offset)

    for lib_path, lib_offsets in libraries_map.iteritems():
      self.AddLibraryOffsets(lib_path, lib_offsets)

  def FindSymbolInfo(self, device_path, offset):
    """Overrides SymbolResolver.FindSymbolInfo.

    Args:
      device_path: Device-specific library path (e.g.
        '/data/app/com.example.app-1/lib/x86/libfoo.so')
      offset: Offset in device library path.
    Returns:
      Corresponding symbol information string, or None.
    """
    host_path = self._host_lib_finder.Find(device_path)
    if not host_path:
      return None

    return self._host_resolver.FindSymbolInfo(host_path, offset)


class MemoryMap(object):
  """Models the memory map of a given process. Usage is:

    1) Create new instance, passing the Android ABI.

    2) Call TranslateLine() whenever you want to detect and translate any
       memory map input line.

    3) Otherwise, it is possible to parse the whole memory map input with
       ParseLines(), then call FindSectionForAddress() repeatedly in order
       to translate a memory address into the corresponding mapping and
       file information tuple (e.g. to symbolize stack entries).
  """

  # A named tuple describing interesting memory map line items.
  # Fields:
  #   addr_start: Mapping start address in memory.
  #   file_offset: Corresponding file offset.
  #   file_size: Corresponding mapping size in bytes.
  #   file_path: Input file path.
  #   match: Corresponding regular expression match object.
  LineTuple = collections.namedtuple('MemoryMapLineTuple',
                                     'addr_start,file_offset,file_size,'
                                     'file_path, match')

  # A name tuple describing a memory map section.
  # Fields:
  #   address: Memory address.
  #   size: Size in bytes in memory
  #   offset: Starting file offset.
  #   path: Input file path.
  SectionTuple = collections.namedtuple('MemoryMapSection',
                                        'address,size,offset,path')

  def __init__(self, android_abi):
    """Initializes instance.

    Args:
      android_abi: Android CPU ABI name (e.g. 'armeabi-v7a')
    """
    hex_addr = _HexAddressRegexpFor(android_abi)

    # pylint: disable=line-too-long
    # A regular expression used to match memory map entries which look like:
    #    b278c000-b2790fff r--   4fda000      5000  /data/app/com.google.android.apps.chrome-2/base.apk
    # pylint: enable=line-too-long
    self._re_map_section = re.compile(
        r'\s*(?P<addr_start>' + hex_addr + r')-(?P<addr_end>' + hex_addr + ')' +
        r'\s+' +
        r'(?P<perm>...)\s+' +
        r'(?P<file_offset>[0-9a-f]+)\s+' +
        r'(?P<file_size>[0-9a-f]+)\s*' +
        r'(?P<file_path>[^ \t]+)?')

    self._addr_map = []  # Sorted list of (address, size, path, offset) tuples.
    self._sorted_addresses = []  # Sorted list of address fields in _addr_map.
    self._in_section = False

  def TranslateLine(self, line, apk_path_translator):
    """Try to translate a memory map input line, if detected.

    This only takes care of converting mapped APK file path and offsets
    into a corresponding uncompressed native library file path + new offsets,
    e.g. '..... <offset> <size> /data/.../base.apk' gets
    translated into '.... <new-offset> <size> /data/.../base.apk!lib/libfoo.so'

    This function should always work, even if ParseLines() was not called
    previously.

    Args:
      line: Input memory map / tombstone line.
      apk_translator: An ApkLibraryPathTranslator instance, used to map
        APK offsets into uncompressed native libraries + new offsets.
    Returns:
      Translated memory map line, if relevant, or unchanged input line
      otherwise.
    """
    t = self._ParseLine(line.rstrip())
    if not t:
      return line

    new_path, new_offset = apk_path_translator.TranslatePath(
        t.file_path, t.file_offset)

    if new_path == t.file_path:
      return line

    pos = t.match.start('file_path')
    return '%s%s (offset 0x%x)%s' % (line[0:pos], new_path, new_offset,
                                     line[t.match.end('file_path'):])

  def ParseLines(self, input_lines, in_section=False):
    """Parse a list of input lines and extract the APK memory map out of it.

    Args:
      input_lines: list, or iterable, of input lines.
      in_section: Optional. If true, considers that the input lines are
        already part of the memory map. Otherwise, wait until the start of
        the section appears in the input before trying to record data.
    Returns:
      True iff APK-related memory map entries were found. False otherwise.
    """
    addr_list = []  # list of (address, size, file_path, file_offset) tuples.
    self._in_section = in_section
    for line in input_lines:
      t = self._ParseLine(line.rstrip())
      if not t:
        continue

      addr_list.append(t)

    self._addr_map = sorted(addr_list,
                            lambda x, y: cmp(x.addr_start, y.addr_start))
    self._sorted_addresses = [e.addr_start for e in self._addr_map]
    return bool(self._addr_map)

  def _ParseLine(self, line):
    """Used internally to recognized memory map input lines.

    Args:
      line: Input logcat or tomstone line.
    Returns:
      A LineTuple instance on success, or None on failure.
    """
    if not self._in_section:
      self._in_section = line.startswith('memory map:')
      return None

    m = self._re_map_section.match(line)
    if not m:
      self._in_section = False  # End of memory map section
      return None

    # Only accept .apk and .so files that are not from the system partitions.
    file_path = m.group('file_path')
    if not file_path:
      return None

    if file_path.startswith('/system') or file_path.startswith('/vendor'):
      return None

    if not (file_path.endswith('.apk') or file_path.endswith('.so')):
      return None

    addr_start = int(m.group('addr_start'), 16)
    file_offset = int(m.group('file_offset'), 16)
    file_size = int(m.group('file_size'), 16)

    return self.LineTuple(addr_start, file_offset, file_size, file_path, m)

  def Dump(self):
    """Print memory map for debugging."""
    print('MEMORY MAP [')
    for t in self._addr_map:
      print('[%08x-%08x %08x %08x %s]' %
            (t.addr_start, t.addr_start + t.file_size, t.file_size,
             t.file_offset, t.file_path))
    print('] MEMORY MAP')

  def FindSectionForAddress(self, addr):
    """Find the map section corresponding to a specific memory address.

    Call this method only after using ParseLines() was called to extract
    relevant information from the memory map.

    Args:
      addr: Memory address
    Returns:
      A SectionTuple instance on success, or None on failure.
    """
    pos = bisect.bisect_right(self._sorted_addresses, addr)
    if pos > 0:
      # All values in [0,pos) are <= addr, just ensure that the last
      # one contains the address as well.
      entry = self._addr_map[pos - 1]
      if entry.addr_start + entry.file_size > addr:
        return self.SectionTuple(entry.addr_start, entry.file_size,
                                 entry.file_offset, entry.file_path)
    return None


class BacktraceTranslator(object):
  """Translates backtrace-related lines in a tombstone or crash report.

  Usage is the following:
    1) Create new instance with appropriate arguments.
    2) If the tombstone / logcat input is available, one can call
       FindLibraryOffsets() in order to detect which library offsets
       will need to be symbolized during a future parse. Doing so helps
       speed up the ELF symbolizer.
    3) For each tombstone/logcat input line, call TranslateLine() to
       try to detect and symbolize backtrace lines.
  """

  # A named tuple for relevant input backtrace lines.
  # Fields:
  #   rel_pc: Instruction pointer, relative to offset in library start.
  #   location: Library or APK file path.
  #   offset: Load base of executable code in library or apk file path.
  #   match: The corresponding regular expression match object.
  # Note:
  #   The actual instruction pointer always matches the position at
  #   |offset + rel_pc| in |location|.
  LineTuple = collections.namedtuple('BacktraceLineTuple',
                                      'rel_pc,location,offset,match')

  def __init__(self, android_abi, apk_translator):
    """Initialize instance.

    Args:
      android_abi: Android CPU ABI name (e.g. 'armeabi-v7a').
      apk_translator: ApkLibraryPathTranslator instance used to convert
        mapped APK file offsets into uncompressed library file paths with
        new offsets.
    """
    hex_addr = _HexAddressRegexpFor(android_abi)

    # A regular expression used to match backtrace lines.
    self._re_backtrace = re.compile(
        r'.*#(?P<frame>[0-9]{2})\s+' +
        r'(..)\s+' +
        r'(?P<rel_pc>' + hex_addr + r')\s+' +
        r'(?P<location>[^ \t]+)' +
        r'(\s+\(offset 0x(?P<offset>[0-9a-f]+)\))?')

    # In certain cases, offset will be provided as <location>+0x<offset>
    # instead of <location> (offset 0x<offset>). This is a regexp to detect
    # this.
    self._re_location_offset = re.compile(
        r'.*\+0x(?P<offset>[0-9a-f]+)$')

    self._apk_translator = apk_translator
    self._in_section = False

  def _ParseLine(self, line):
    """Used internally to detect and decompose backtrace input lines.

    Args:
      line: input tombstone line.
    Returns:
      A LineTuple instance on success, None on failure.
    """
    if not self._in_section:
      self._in_section = line.startswith('backtrace:')
      return None

    line = line.rstrip()
    m = self._re_backtrace.match(line)
    if not m:
      self._in_section = False
      return None

    location = m.group('location')
    offset = m.group('offset')
    if not offset:
      m2 = self._re_location_offset.match(location)
      if m2:
        offset = m2.group('offset')
        location = location[0:m2.start('offset') - 3]

    if not offset:
      return None

    offset = int(offset, 16)
    rel_pc = int(m.group('rel_pc'), 16)

    # Two cases to consider here:
    #
    # * If this is a library file directly mapped in memory, then |rel_pc|
    #   if the direct offset within the library, and doesn't need any kind
    #   of adjustement.
    #
    # * If this is a library mapped directly from an .apk file, then
    #   |rel_pc| is the offset in the APK, and |offset| happens to be the
    #   load base of the corresponding library.
    #
    if location.endswith('.so'):
      # For a native library directly mapped from the file system,
      return self.LineTuple(rel_pc, location, offset, m)

    if location.endswith('.apk'):
      # For a native library inside an memory-mapped APK file,
      new_location, new_offset = self._apk_translator.TranslatePath(
          location, offset)

      return self.LineTuple(rel_pc, new_location, new_offset, m)

    # Ignore anything else (e.g. .oat or .odex files).
    return None

  def FindLibraryOffsets(self, input_lines, in_section=False):
    """Parse a tombstone's backtrace section and find all library offsets in it.

    Args:
      input_lines: List or iterables of intput tombstone lines.
      in_section: Optional. If True, considers that the stack section has
        already started.
    Returns:
      A dictionary mapping device library paths to sets of offsets within
      then.
    """
    self._in_section = in_section
    result = collections.defaultdict(set)
    for line in input_lines:
      t = self._ParseLine(line)
      if not t:
        continue

      result[t.location].add(t.offset + t.rel_pc)
    return result

  def TranslateLine(self, line, symbol_resolver):
    """Symbolize backtrace line if recognized.

    Args:
      line: input backtrace line.
      symbol_resolver: symbol resolver instance to use. This method will
        call its FindSymbolInfo(device_lib_path, lib_offset) method to
        convert offsets into symbol informations strings.
    Returns:
      Translated line (unchanged if not recognized as a back trace).
    """
    t = self._ParseLine(line)
    if not t:
      return line

    symbol_info = symbol_resolver.FindSymbolInfo(t.location,
                                                 t.offset + t.rel_pc)
    if not symbol_info:
      symbol_info = 'offset 0x%x' % t.offset

    pos = t.match.start('location')
    pos2 = t.match.end('offset') + 1
    if pos2 <= 0:
      pos2 = t.match.end('location')
    return '%s%s (%s)%s' % (line[:pos], t.location, symbol_info, line[pos2:])


class StackTranslator(object):
  """Translates stack-related lines in a tombstone or crash report."""

  # A named tuple describing relevant stack input lines.
  # Fields:
  #  address: Address as it appears in the stack.
  #  lib_path: Library path where |address| is mapped.
  #  lib_offset: Library load base offset. for |lib_path|.
  #  match: Corresponding regular expression match object.
  LineTuple = collections.namedtuple('StackLineTuple',
                                     'address, lib_path, lib_offset, match')

  def __init__(self, android_abi, memory_map, apk_translator):
    """Initialize instance."""
    hex_addr = _HexAddressRegexpFor(android_abi)

    # pylint: disable=line-too-long
    # A regular expression used to recognize stack entries like:
    #
    #    #05  bf89a180  bf89a1e4  [stack]
    #         bf89a1c8  a0c01c51  /data/app/com.google.android.apps.chrome-2/base.apk
    #         bf89a080  00000000
    #         ........  ........
    # pylint: enable=line-too-long
    self._re_stack_line = re.compile(
        r'\s+(?P<frame_number>#[0-9]+)?\s*' +
        r'(?P<stack_addr>' + hex_addr + r')\s+' +
        r'(?P<stack_value>' + hex_addr + r')' +
        r'(\s+(?P<location>[^ \t]+))?')

    self._re_stack_abbrev = re.compile(r'\s+[.]+\s+[.]+')

    self._memory_map = memory_map
    self._apk_translator = apk_translator
    self._in_section = False

  def _ParseLine(self, line):
    """Check a given input line for a relevant _re_stack_line match.

    Args:
      line: input tombstone line.
    Returns:
      A LineTuple instance on success, None on failure.
    """
    line = line.rstrip()
    if not self._in_section:
      self._in_section = line.startswith('stack:')
      return None

    m = self._re_stack_line.match(line)
    if not m:
      if not self._re_stack_abbrev.match(line):
        self._in_section = False
      return None

    location = m.group('location')
    if not location:
      return None

    if not location.endswith('.apk') and not location.endswith('.so'):
      return None

    addr = int(m.group('stack_value'), 16)
    t = self._memory_map.FindSectionForAddress(addr)
    if t is None:
      return None

    lib_path = t.path
    lib_offset = t.offset + (addr - t.address)

    if lib_path.endswith('.apk'):
      lib_path, lib_offset = self._apk_translator.TranslatePath(
          lib_path, lib_offset)

    return self.LineTuple(addr, lib_path, lib_offset, m)

  def FindLibraryOffsets(self, input_lines, in_section=False):
    """Parse a tombstone's stack section and find all library offsets in it.

    Args:
      input_lines: List or iterables of intput tombstone lines.
      in_section: Optional. If True, considers that the stack section has
        already started.
    Returns:
      A dictionary mapping device library paths to sets of offsets within
      then.
    """
    result = collections.defaultdict(set)
    self._in_section = in_section
    for line in input_lines:
      t = self._ParseLine(line)
      if t:
        result[t.lib_path].add(t.lib_offset)
    return result

  def TranslateLine(self, line, symbol_resolver=None):
    """Try to translate a line of the stack dump."""
    t = self._ParseLine(line)
    if not t:
      return line

    symbol_info = symbol_resolver.FindSymbolInfo(t.lib_path, t.lib_offset)
    if not symbol_info:
      return line

    pos = t.match.start('location')
    pos2 = t.match.end('location')
    return '%s%s (%s)%s' % (line[:pos], t.lib_path, symbol_info, line[pos2:])