supersize: Don't cluster by default. Make Diff() accept only SizeInfo.

tools/binary_size/libsupersize/models.py

 # Copyright 2017 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.
 """Classes that comprise the data model for binary size analysis.
 
 The primary classes are Symbol, and SymbolGroup.
 
 Description of common properties:
   * address: The start address of the symbol.
         May be 0 (e.g. for .bss or for SymbolGroups).
@@ skipping 11 matching lines @@
        are removed from both full_name and name during normalization).
   * section_name: E.g. ".text", ".rodata", ".data.rel.local"
   * section: The second character of |section_name|. E.g. "t", "r", "d".
 """
 
 import collections
 import logging
 import os
 import re
 
+import cluster_symbols
 import match_util
 
 
 METADATA_GIT_REVISION = 'git_revision'
 METADATA_APK_FILENAME = 'apk_file_name'  # Path relative to output_directory.
 METADATA_MAP_FILENAME = 'map_file_name'  # Path relative to output_directory.
 METADATA_ELF_ARCHITECTURE = 'elf_arch'  # "Machine" field from readelf -h
 METADATA_ELF_FILENAME = 'elf_file_name'  # Path relative to output_directory.
 METADATA_ELF_MTIME = 'elf_mtime'  # int timestamp in utc.
 METADATA_ELF_BUILD_ID = 'elf_build_id'
@@ skipping 19 matching lines @@
   if clone_idx != -1:
     return name[:clone_idx]
   return name
 
 
 class SizeInfo(object):
   """Represents all size information for a single binary.
 
   Fields:
     section_sizes: A dict of section_name -> size.
-    raw_symbols: A flat list of all symbols.
-    symbols: A SymbolGroup containing raw_symbols, but with some Symbols grouped
-        into sub-SymbolGroups.
+    symbols: A SymbolGroup containing all symbols, sorted by address.
     metadata: A dict.
   """
   __slots__ = (
       'section_sizes',
-      'raw_symbols',
       'symbols',
       'metadata',
   )
 
   """Root size information."""
-  def __init__(self, section_sizes, raw_symbols, grouped_symbols=None,
-               metadata=None):
+  def __init__(self, section_sizes, symbols, metadata=None):
     self.section_sizes = section_sizes  # E.g. {'.text': 0}
-    # List of symbols sorted by address per-section.
-    self.raw_symbols = raw_symbols
-    # Root SymbolGroup. Cloned symbols grouped together within sub-SymbolGroups.
-    self.symbols = grouped_symbols
+    self.symbols = symbols
     self.metadata = metadata or {}
 
+  def Cluster(self):
+    """Returns a new SizeInfo with some symbols moved into subgroups.
+
+    See SymbolGroup.Cluster() for more details.
+    """
+    return SizeInfo(self.section_sizes, self.symbols.Cluster(), self.metadata)
+
 
 class SizeInfoDiff(object):
   """What you get when you Diff() two SizeInfo objects.
 
   Fields:
     section_sizes: A dict of section_name -> size delta.
     symbols: A SymbolDiff with all symbols in it.
     before_metadata: metadata of the "before" SizeInfo.
     after_metadata: metadata of the "after" SizeInfo.
   """
@@ skipping 268 matching lines @@
     return self._padding
 
   @property
   def aliases(self):
     return None
 
   def IsGroup(self):
     return True
 
   def _CreateTransformed(self, symbols, filtered_symbols=None, name=None,
-                         section_name=None, is_sorted=None):
+                         full_name=None, section_name=None, is_sorted=None):
     if is_sorted is None:
       is_sorted = self.is_sorted
     return SymbolGroup(symbols, filtered_symbols=filtered_symbols, name=name,
-                       section_name=section_name, is_sorted=is_sorted)
+                       full_name=full_name, section_name=section_name,
+                       is_sorted=is_sorted)
+
+  def Cluster(self):
+    """Returns a new SymbolGroup with some symbols moved into subgroups.
+
+    Subgroups include:
+     * Symbols that have [clone] in their name (created during inlining).
+     * Star symbols (such as "** merge strings", and "** symbol gap")
+
+    To view created groups:
+      Print(clustered.Filter(lambda s: s.IsGroup()), recursive=True)
+    """
+    return self._CreateTransformed(cluster_symbols.ClusterSymbols(self))
 
   def Sorted(self, cmp_func=None, key=None, reverse=False):
     # Default to sorting by abs(size) then name.
     if cmp_func is None and key is None:
       cmp_func = lambda a, b: cmp((a.IsBss(), abs(b.size), a.name),
                                   (b.IsBss(), abs(a.size), b.name))
 
     after_symbols = sorted(self._symbols, cmp_func, key, reverse)
     return self._CreateTransformed(
         after_symbols, filtered_symbols=self._filtered_symbols,
@@ skipping 224 matching lines @@
     symbols.extend(similar)
     super(SymbolDiff, self).__init__(symbols, name=name, full_name=full_name,
                                      section_name=section_name)
 
   def __repr__(self):
     return '%s(%d added, %d removed, %d changed, %d unchanged, size=%d)' % (
         'SymbolGroup', self.added_count, self.removed_count, self.changed_count,
         self.unchanged_count, self.size)
 
   def _CreateTransformed(self, symbols, filtered_symbols=None, name=None,
-                         section_name=None, is_sorted=None):
+                         full_name=None, section_name=None, is_sorted=None):
+    # Printing sorts, so short-circuit the same symbols case.
+    if len(symbols) == len(self._symbols):
+      new_added_ids = self._added_ids
+      new_removed_ids = self._removed_ids
+    else:
+      old_added_ids = self._added_ids
+      old_removed_ids = self._removed_ids
+
+      def get_status(sym):
+        obj_id = id(sym)
+        if obj_id in old_added_ids:
+          return 0
+        if obj_id in old_removed_ids:
+          return 1
+        if sym.IsGroup():
+          first_status = get_status(sym[0])
+          if all(get_status(s) == first_status for s in sym[1:]):
+            return first_status
+        return 2
+
+      new_added_ids = set()
+      new_removed_ids = set()
+      for sym in symbols:
+        status = get_status(sym)
+        if status == 0:
+          new_added_ids.add(id(sym))
+        elif status == 1:
+          new_removed_ids.add(id(sym))
+
     ret = SymbolDiff.__new__(SymbolDiff)
-    # Printing sorts, so fast-path the same symbols case.
-    if len(symbols) == len(self._symbols):
-      ret._added_ids = self._added_ids
-      ret._removed_ids = self._removed_ids
-    else:
-      ret._added_ids = set(id(s) for s in symbols if self.IsAdded(s))
-      ret._removed_ids = set(id(s) for s in symbols if self.IsRemoved(s))
+    ret._added_ids = new_added_ids
+    ret._removed_ids = new_removed_ids
     super(SymbolDiff, ret).__init__(
         symbols, filtered_symbols=filtered_symbols, name=name,
-        section_name=section_name, is_sorted=is_sorted)
+        full_name=full_name, section_name=section_name, is_sorted=is_sorted)
     return ret
 
   @property
   def added_count(self):
     return len(self._added_ids)
 
   @property
   def removed_count(self):
     return len(self._removed_ids)
 
@@ skipping 22 matching lines @@
 
 def _ExtractPrefixBeforeSeparator(string, separator, count=1):
   idx = -len(separator)
   prev_idx = None
   for _ in xrange(count):
     idx = string.find(separator, idx + len(separator))
     if idx < 0:
       break
     prev_idx = idx
   return string[:prev_idx]