binary_size_tool: fix for ambiguous addr2line output

build/android/pylib/symbols/elf_symbolizer.py

 # Copyright 2014 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.
 
 import collections
 import datetime
 import logging
 import multiprocessing
 import os
 import posixpath
 import Queue
 import re
 import subprocess
 import sys
 import threading
-
+from sets import Set
 
 # addr2line builds a possibly infinite memory cache that can exhaust
 # the computer's memory if allowed to grow for too long. This constant
 # controls how many lookups we do before restarting the process. 4000
 # gives near peak performance without extreme memory usage.
 ADDR2LINE_RECYCLE_LIMIT = 4000
 
 
 class ELFSymbolizer(object):
   """An uber-fast (multiprocessing, pipelined and asynchronous) ELF symbolizer.
@@ skipping 41 matching lines @@
   |max_queue_size| bound, a new addr2line instance is kicked in.
   In the case of a very eager producer (i.e. all |max_concurrent_jobs| instances
   have a backlog of |max_queue_size|), back-pressure is applied on the caller by
   blocking the SymbolizeAsync method.
 
   This module has been deliberately designed to be dependency free (w.r.t. of
   other modules in this project), to allow easy reuse in external projects.
   """
 
   def __init__(self, elf_file_path, addr2line_path, callback, inlines=False,
-      max_concurrent_jobs=None, addr2line_timeout=30, max_queue_size=50):
+      max_concurrent_jobs=None, addr2line_timeout=30, max_queue_size=50,
+      disambiguate=False, disambiguation_source_path=''):
     """Args:
       elf_file_path: path of the elf file to be symbolized.
       addr2line_path: path of the toolchain's addr2line binary.
       callback: a callback which will be invoked for each resolved symbol with
           the two args (sym_info, callback_arg). The former is an instance of
           |ELFSymbolInfo| and contains the symbol information. The latter is an
           embedder-provided argument which is passed to SymbolizeAsync().
       inlines: when True, the ELFSymbolInfo will contain also the details about
           the outer inlining functions. When False, only the innermost function
           will be provided.
       max_concurrent_jobs: Max number of addr2line instances spawned.
           Parallelize responsibly, addr2line is a memory and I/O monster.
       max_queue_size: Max number of outstanding requests per addr2line instance.
       addr2line_timeout: Max time (in seconds) to wait for a addr2line response.
           After the timeout, the instance will be considered hung and respawned.
+      disambiguate: Whether to run a disambiguation process or not.
+          Disambiguation means to resolve ambigious source_paths,

[Andrew Hayden (chromium.org), 2014/06/17 11:36:27]

ambigious -> ambiguous (Spelling)

You may also want to add a short note something like:
In some toolchains only the name of the source file is output, without any path
information; disambiguation searches through the source directory specified by
--disambiguate_source_path for files whose name matches. If there are multiple
files with the same name, disambiguation will fail.

+          example turn addr2line output "unicode.cc" into a full and absolute

[Andrew Hayden (chromium.org), 2014/06/17 11:36:27]

"for example" instead of "example"

+          path
+      disambiguate_source_path: The path of the source code that the

[Andrew Hayden (chromium.org), 2014/06/17 11:36:27]

I'd say: the path to the directory where source files are located, used for
disambiguating paths.

+          disambiguation will lookup source files
     """
     assert(os.path.isfile(addr2line_path)), 'Cannot find ' + addr2line_path
     self.elf_file_path = elf_file_path
     self.addr2line_path = addr2line_path
     self.callback = callback
     self.inlines = inlines
     self.max_concurrent_jobs = (max_concurrent_jobs or
                                 min(multiprocessing.cpu_count(), 4))
     self.max_queue_size = max_queue_size
     self.addr2line_timeout = addr2line_timeout
     self.requests_counter = 0  # For generating monotonic request IDs.
     self._a2l_instances = []  # Up to |max_concurrent_jobs| _Addr2Line inst.
 
+    # If necessary, create disambiguation lookup table
+    self.disambiguate = disambiguate
+    self.commonprefix = ''
+    self.lookup_table = {}
+    if(self.disambiguate):
+      self._CreateDisambiguationTable(disambiguation_source_path)
+
     # Create one addr2line instance. More instances will be created on demand
     # (up to |max_concurrent_jobs|) depending on the rate of the requests.
     self._CreateNewA2LInstance()
 
   def SymbolizeAsync(self, addr, callback_arg=None):
     """Requests symbolization of a given address.
 
     This method is not guaranteed to return immediately. It generally does, but
     in some scenarios (e.g. all addr2line instances have full queues) it can
     block to create back-pressure.
@@ skipping 37 matching lines @@
     for a2l in self._a2l_instances:
       a2l.WaitForIdle()
       a2l.Terminate()
 
   def _CreateNewA2LInstance(self):
     assert(len(self._a2l_instances) < self.max_concurrent_jobs)
     a2l = ELFSymbolizer.Addr2Line(self)
     self._a2l_instances.append(a2l)
     return a2l
 
+  def _CreateDisambiguationTable(self, src_root_path):
+    """ Creates a table of files used for disambiguation later
+        Disambiguation:
+          addr2line sometimes return an ambigous file-name rather than the
+          full path of the file where the symbol is located.
+
+        adopted from andrewhaydens implementation in earlier commits """
+    interesting_file_endings = { ".c", ".cc", ".h", ".cp", ".cpp", ".cxx",
+                                 ".c++", ".asm", ".inc", ".s", ".hxx" }
+    duplicates = Set()
+    self.lookup_table = {}
+    src_root_path = os.path.abspath(src_root_path)
+
+    for root, _, filenames in os.walk(src_root_path):
+      for f in filenames:
+        _, ext = os.path.splitext(f)
+        if not ext in interesting_file_endings:
+          continue
+
+        base = os.path.basename(f)  # Just in case
+        if self.lookup_table.get(base) is None:
+          self.lookup_table[base] = "%s/%s" % (root, f)
+        else:
+          duplicates.add(base)
+
+    # Duplicates can not be used for disambiguation, as we can not determine
+    # the true source if we have more than one to choose from
+    for d in duplicates:
+      del self.lookup_table[d]
+
+    # Get the common prefix for the source paths
+    self.commonprefix = os.path.commonprefix(self.lookup_table.values())
 
   class Addr2Line(object):
     """A python wrapper around an addr2line instance.
 
     The communication with the addr2line process looks as follows:
       [STDIN]         [STDOUT]  (from addr2line's viewpoint)
     > f001111
     > f002222
                     < Symbol::Name(foo, bar) for f001111
                     < /path/to/source/file.c:line_number
@@ skipping 125 matching lines @@
       innermost_sym_info = None
       sym_info = None
       for (line1, line2) in lines:
         prev_sym_info = sym_info
         name = line1 if not line1.startswith('?') else None
         source_path = None
         source_line = None
         m = ELFSymbolizer.Addr2Line.SYM_ADDR_RE.match(line2)
         if m:
           if not m.group(1).startswith('?'):
-            source_path = m.group(1)
+            source_path = os.path.abspath(m.group(1))
             if not m.group(2).startswith('?'):
               source_line = int(m.group(2))
         else:
           logging.warning('Got invalid symbol path from addr2line: %s' % line2)
 
-        sym_info = ELFSymbolInfo(name, source_path, source_line)
+        # In case disambiguation is on, and needed
+        disambiguated = False
+        if self._symbolizer.disambiguate:
+          # Strip the common prefix to determine whether the source is ambigous

[Andrew Hayden (chromium.org), 2014/06/17 11:36:27]

"ambiguous"

+          # or not (we assume that there are no source files in the common
+          # prefix of the paths)
+          if not source_path is None:
+            common_prefix = self._symbolizer.commonprefix
+            if source_path.startswith(common_prefix):
+              path = source_path[len(common_prefix):]
+              # In case no '/' character is found in this "relative" path
+              # it is most likely that addr2line did not get the whole path
+              if not path.find('/') != -1:

[Andrew Hayden (chromium.org), 2014/06/17 11:36:27]

Double negation is hard to reason about. How about:
if not path.find('/'):

+                source_path = self._symbolizer.lookup_table.get(path)
+                disambiguated = True
+
+        sym_info = ELFSymbolInfo(name, source_path, source_line, disambiguated)
         if prev_sym_info:
           prev_sym_info.inlined_by = sym_info
         if not innermost_sym_info:
           innermost_sym_info = sym_info
 
       self._processed_symbols_count += 1
       self._symbolizer.callback(innermost_sym_info, callback_arg)
 
     def _RestartAddr2LineProcess(self):
       if self._proc:
@@ skipping 60 matching lines @@
 
     @property
     def first_request_id(self):
       """Returns the request_id of the oldest pending request in the queue."""
       return self._request_queue[0][2] if self._request_queue else 0
 
 
 class ELFSymbolInfo(object):
   """The result of the symbolization passed as first arg. of each callback."""
 
-  def __init__(self, name, source_path, source_line):
+  def __init__(self, name, source_path, source_line, disambiguated=False):
     """All the fields here can be None (if addr2line replies with '??')."""
     self.name = name
     self.source_path = source_path
     self.source_line = source_line
     # In the case of |inlines|=True, the |inlined_by| points to the outer
     # function inlining the current one (and so on, to form a chain).
     self.inlined_by = None
+    self.disambiguated = disambiguated
 
   def __str__(self):
     return '%s [%s:%d]' % (
         self.name or '??', self.source_path or '??', self.source_line or 0)