Binary size tool, handle symbols with no path better.

tools/binary_size/explain_binary_size_delta.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.
 
 """Describe the size difference of two binaries.
 
 Generates a description of the size difference of two binaries based
 on the difference of the size of various symbols.
 
@@ skipping 19 matching lines @@
       --destdir /tmp/throwaway
       --nm-out /tmp/nm2.dump
 
   # cleanup useless files
   rm -r /tmp/throwaway
 
   # run this tool
   explain_binary_size_delta.py --nm1 /tmp/nm1.dump --nm2 /tmp/nm2.dump
 """
 
+import collections
 import operator
 import optparse
 import os
 import sys
 
 import binary_size_utils
 
 
 def Compare(symbols1, symbols2):
   """Executes a comparison of the symbols in symbols1 and symbols2.
@@ skipping 12 matching lines @@
   for cache, symbols in ((cache1, symbols1), (cache2, symbols2)):
     for symbol_name, symbol_type, symbol_size, file_path in symbols:
       if 'vtable for ' in symbol_name:
         symbol_type = '@' # hack to categorize these separately
       if file_path:
         file_path = os.path.normpath(file_path)
       else:
         file_path = '(No Path)'
       key = (file_path, symbol_type)
       bucket = cache.setdefault(key, {})
-      bucket[symbol_name] = symbol_size
+      size_list = bucket.setdefault(symbol_name, [])
+      size_list.append(symbol_size)
 
   # Now diff them. We iterate over the elements in cache1. For each symbol
   # that we find in cache2, we record whether it was deleted, changed, or
   # unchanged. We then remove it from cache2; all the symbols that remain
   # in cache2 at the end of the iteration over cache1 are the 'new' symbols.
   for key, bucket1 in cache1.items():
     bucket2 = cache2.get(key)
     if not bucket2:
       # A file was removed. Everything in bucket1 is dead.
-      for symbol_name, symbol_size in bucket1.items():
-        removed.append((key[0], key[1], symbol_name, symbol_size, None))
+      for symbol_name, symbol_size_list in bucket1.items():
+        for symbol_size in symbol_size_list:
+          removed.append((key[0], key[1], symbol_name, symbol_size, None))
     else:
       # File still exists, look for changes within.
-      for symbol_name, symbol_size in bucket1.items():
-        size2 = bucket2.get(symbol_name)
-        if size2 is None:
+      for symbol_name, symbol_size_list in bucket1.items():
+        size_list2 = bucket2.get(symbol_name)
+        if size_list2 is None:
           # Symbol no longer exists in bucket2.
-          removed.append((key[0], key[1], symbol_name, symbol_size, None))
+          for symbol_size in symbol_size_list:
+            removed.append((key[0], key[1], symbol_name, symbol_size, None))
         else:
           del bucket2[symbol_name] # Symbol is not new, delete from cache2.
+          if len(symbol_size_list) == 1 and len(size_list2) == 1:
+            symbol_size = symbol_size_list[0]
+            size2 = size_list2[0]
+            if symbol_size != size2:
+              # Symbol has change size in bucket.
+              changed.append((key[0], key[1], symbol_name, symbol_size, size2))
+            else:
+              # Symbol is unchanged.
+              unchanged.append((key[0], key[1], symbol_name, symbol_size,
+                                size2))
+          else:
+            # Complex comparison for when a symbol exists multiple times
+            # in the same file (where file can be "unknown file").
+            symbol_size_counter = collections.Counter(symbol_size_list)
+            delta_counter = collections.Counter(symbol_size_list)
+            delta_counter.subtract(size_list2)
+            for symbol_size in sorted(delta_counter.keys()):
+              delta = delta_counter[symbol_size]
+              unchanged_count = symbol_size_counter[symbol_size]
+              if delta > 0:
+                unchanged_count -= delta
+              for _ in range(unchanged_count):
+                unchanged.append((key[0], key[1], symbol_name, symbol_size,
+                                  symbol_size))
+              if delta > 0: # Used to be more of these than there is now.
+                for _ in range(delta):
+                  removed.append((key[0], key[1], symbol_name, symbol_size,
+                                  None))
+              elif delta < 0: # More of this (symbol,size) now.
+                for _ in range(-delta):
+                  added.append((key[0], key[1], symbol_name, None, symbol_size))
+
           if len(bucket2) == 0:
             del cache1[key] # Entire bucket is empty, delete from cache2
-          if symbol_size != size2:
-            # Symbol has change size in bucket.
-            changed.append((key[0], key[1], symbol_name, symbol_size, size2))
-          else:
-            # Symbol is unchanged.
-            unchanged.append((key[0], key[1], symbol_name, symbol_size, size2))
 
   # We have now analyzed all symbols that are in cache1 and removed all of
   # the encountered symbols from cache2. What's left in cache2 is the new
   # symbols.
   for key, bucket2 in cache2.iteritems():
-    for symbol_name, symbol_size in bucket2.items():
-      added.append((key[0], key[1], symbol_name, None, symbol_size))
+    for symbol_name, symbol_size_list in bucket2.items():
+      for symbol_size in symbol_size_list:
+        added.append((key[0], key[1], symbol_name, None, symbol_size))
   return (added, removed, changed, unchanged)
 
 def DeltaStr(number):
   """Returns the number as a string with a '+' prefix if it's > 0 and
   a '-' prefix if it's < 0."""
   result = str(number)
   if number > 0:
     result = '+' + result
   return result
 
@@ skipping 202 matching lines @@
     with file(path, 'r') as nm_input:
       if opts.verbose:
         print 'parsing ' + path + '...'
       symbols.append(list(binary_size_utils.ParseNm(nm_input)))
   (added, removed, changed, unchanged) = Compare(symbols[0], symbols[1])
   CrunchStats(added, removed, changed, unchanged,
     opts.showsources | opts.showsymbols, opts.showsymbols)
 
 if __name__ == '__main__':
   sys.exit(main())