binary_size_tool: fix for ambiguous addr2line output

tools/binary_size/run_binary_size_analysis.py

 #!/usr/bin/env python
 # 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.
 
 """Generate a spatial analysis against an arbitrary library.
 
 To use, build the 'binary_size_tool' target. Then run this tool, passing
 in the location of the library to be analyzed along with any other options
 you desire.
@@ skipping 464 matching lines @@
 sNmPattern = re.compile(
   r'([0-9a-f]{8,})[\s]+([0-9a-f]{8,})[\s]*(\S?)[\s*]([^\t]*)[\t]?(.*)')
 
 class Progress():
   def __init__(self):
     self.count = 0
     self.skip_count = 0
     self.collisions = 0
     self.time_last_output = time.time()
     self.count_last_output = 0
+    self.disambiguations = 0
+    self.failed_disambiguations = 0
 
 
-def RunElfSymbolizer(outfile, library, addr2line_binary, nm_binary, jobs):
+def RunElfSymbolizer(outfile, library, addr2line_binary, nm_binary, jobs,
+                     disambiguate, src_path):
   nm_output = RunNm(library, nm_binary)
   nm_output_lines = nm_output.splitlines()
   nm_output_lines_len = len(nm_output_lines)
   address_symbol = {}
   progress = Progress()
   def map_address_symbol(symbol, addr):
     progress.count += 1
     if addr in address_symbol:
       # 'Collision between %s and %s.' % (str(symbol.name),
       #                                   str(address_symbol[addr].name))
       progress.collisions += 1
     else:
+      if symbol.disambiguated:
+        progress.disambiguations += 1
+      if symbol.failed_disambiguation:
+        progress.failed_disambiguations += 1
+
       address_symbol[addr] = symbol
 
     progress_chunk = 100
     if progress.count % progress_chunk == 0:
       time_now = time.time()
       time_spent = time_now - progress.time_last_output
       if time_spent > 1.0:
         # Only output at most once per second.
         progress.time_last_output = time_now
         chunk_size = progress.count - progress.count_last_output
         progress.count_last_output = progress.count
         if time_spent > 0:
           speed = chunk_size / time_spent
         else:
           speed = 0
         progress_percent = (100.0 * (progress.count + progress.skip_count) /
                             nm_output_lines_len)
-        print('%.1f%%: Looked up %d symbols (%d collisions) - %.1f lookups/s.' %
-              (progress_percent, progress.count, progress.collisions, speed))
+        disambiguation_percent = 0
+        if progress.disambiguations != 0:
+          disambiguation_percent = (100.0 * progress.disambiguations /
+                   (progress.disambiguations + progress.failed_disambiguations))
+        sys.stdout.write('\r%.1f%%: Looked up %d symbols (%d collisions, '
+              '%d disambiguations where %.1f%% succeeded)'
+              '- %.1f lookups/s.' %
+              (progress_percent, progress.count, progress.collisions,
+               progress.disambiguations, disambiguation_percent, speed))
 
   symbolizer = elf_symbolizer.ELFSymbolizer(library, addr2line_binary,
                                             map_address_symbol,
-                                            max_concurrent_jobs=jobs)
+                                            max_concurrent_jobs=jobs,
+                                            disambiguate=disambiguate,
+                                            disambiguation_source_path=src_path)
   user_interrupted = False
   try:
     for line in nm_output_lines:
       match = sNmPattern.match(line)
       if match:
         location = match.group(5)
         if not location:
           addr = int(match.group(1), 16)
           size = int(match.group(2), 16)
           if addr in address_symbol:  # Already looked up, shortcut
@@ skipping 12 matching lines @@
     user_interrupted = True
     print('Interrupting - killing subprocesses. Please wait.')
 
   try:
     symbolizer.Join()
   except KeyboardInterrupt:
     # Don't want to abort here since we will be finished in a few seconds.
     user_interrupted = True
     print('Patience you must have my young padawan.')
 
+  print ''
+
   if user_interrupted:
     print('Skipping the rest of the file mapping. '
           'Output will not be fully classified.')
 
   with open(outfile, 'w') as out:
     for line in nm_output_lines:
       match = sNmPattern.match(line)
       if match:
         location = match.group(5)
         if not location:
@@ skipping 27 matching lines @@
     if err_output:
       raise Exception, err_output
     else:
       raise Exception, process_output
 
   print('Finished nm')
   return process_output
 
 
 def GetNmSymbols(nm_infile, outfile, library, jobs, verbose,
-                 addr2line_binary, nm_binary):
+                 addr2line_binary, nm_binary, disambiguate, src_path):
   if nm_infile is None:
     if outfile is None:
       outfile = tempfile.NamedTemporaryFile(delete=False).name
 
     if verbose:
       print 'Running parallel addr2line, dumping symbols to ' + outfile
-    RunElfSymbolizer(outfile, library, addr2line_binary, nm_binary, jobs)
+    RunElfSymbolizer(outfile, library, addr2line_binary, nm_binary, jobs,
+                     disambiguate, src_path)
 
     nm_infile = outfile
 
   elif verbose:
     print 'Using nm input from ' + nm_infile
   with file(nm_infile, 'r') as infile:
     return list(binary_size_utils.ParseNm(infile))
 
 
 def _find_in_system_path(binary):
@@ skipping 89 matching lines @@
                     help='be verbose, printing lots of status information.')
   parser.add_option('--nm-out', metavar='PATH',
                     help='keep the nm output file, and store it at the '
                     'specified path. This is useful if you want to see the '
                     'fully processed nm output after the symbols have been '
                     'mapped to source locations. By default, a tempfile is '
                     'used and is deleted when the program terminates.'
                     'This argument is only valid when using --library.')
   parser.add_option('--legacy', action='store_true',
                     help='emit legacy binary size report instead of modern')
+  parser.add_option('--disable-disambiguation', action='store_true',
+                    help='disables the disambiguation process altogether,'
+                    ' NOTE: this will produce output with some symbols at the'
+                    ' top layer due to the fact that addr2line could not get'
+                    ' the entire source path.')
+  parser.add_option('--source-path', default='./',
+                    help='the path to the source code of the output binary, '
+                    'default set to current directory. Used in the'
+                    ' disambiguation process.')
   opts, _args = parser.parse_args()
 
   if ((not opts.library) and (not opts.nm_in)) or (opts.library and opts.nm_in):
     parser.error('exactly one of --library or --nm-in is required')
   if (opts.nm_in):
     if opts.jobs:
       print >> sys.stderr, ('WARNING: --jobs has no effect '
                             'when used with --nm-in')
   if not opts.destdir:
     parser.error('--destdir is required argument')
@@ skipping 20 matching lines @@
     assert nm_binary, 'Unable to find nm in the path. Use --nm-binary '\
         'to specify location.'
 
   print('addr2line: %s' % addr2line_binary)
   print('nm: %s' % nm_binary)
 
   CheckDebugFormatSupport(opts.library, addr2line_binary)
 
   symbols = GetNmSymbols(opts.nm_in, opts.nm_out, opts.library,
                          opts.jobs, opts.verbose is True,
-                         addr2line_binary, nm_binary)
+                         addr2line_binary, nm_binary,
+                         not opts.disable_disambiguation,
+                         opts.source_path)
   if not os.path.exists(opts.destdir):
     os.makedirs(opts.destdir, 0755)
 
 
   if opts.legacy: # legacy report
     DumpTreemap(symbols, os.path.join(opts.destdir, 'treemap-dump.js'))
     DumpLargestSymbols(symbols,
                          os.path.join(opts.destdir, 'largest-symbols.js'), 100)
     DumpLargestSources(symbols,
                          os.path.join(opts.destdir, 'largest-sources.js'), 100)
@@ skipping 22 matching lines @@
     shutil.copy(os.path.join(d3_src, 'LICENSE'), d3_out)
     shutil.copy(os.path.join(d3_src, 'd3.js'), d3_out)
     shutil.copy(os.path.join(template_src, 'index.html'), opts.destdir)
     shutil.copy(os.path.join(template_src, 'D3SymbolTreeMap.js'), opts.destdir)
 
   print 'Report saved to ' + opts.destdir + '/index.html'
 
 
 if __name__ == '__main__':
   sys.exit(main())