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

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

In the old code I also counted the number of disambiguation attempts that
failed, and output that number as well. This is useful because it gives you an
idea of whether or not disambiguation is working and how effectively. This is
still an improvement so I'm not saying you have to do this right now, but it
would be nice to keep the feature.

 
 
-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
       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))
+        print('%.1f%%: Looked up %d symbols (%d collisions, %d disambiguations)'
+              '- %.1f lookups/s.' %
+              (progress_percent, progress.count, progress.collisions,
+               progress.disambiguations, 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 59 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())