Supersize: Chrome-specific breakdowns, console tweaks

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 315 matching lines @@
   @property
   def object_path(self):
     first = self._symbols[0].object_path if self else ''
     return first if all(s.object_path == first for s in self._symbols) else ''
 
   @property
   def source_path(self):
     first = self._symbols[0].source_path if self else ''
     return first if all(s.source_path == first for s in self._symbols) else ''
 
-  def IterUniqueSymbols(self):
-    seen_aliases_lists = set()
-    for s in self:
-      if not s.aliases:
-        yield s
-      elif id(s.aliases) not in seen_aliases_lists:
-        seen_aliases_lists.add(id(s.aliases))
-        yield s
-
-  def CountUniqueSymbols(self):
-    return sum(1 for s in self.IterUniqueSymbols())
-
   @property
   def size(self):
     if self._size is None:
       if self.IsBss():
         self._size = sum(s.size for s in self)
       else:
         self._size = sum(s.size for s in self.IterUniqueSymbols())
     return self._size
 
   @property
@@ skipping 11 matching lines @@
       self._padding = sum(s.padding for s in self.IterUniqueSymbols())
     return self._padding
 
   @property
   def aliases(self):
     return None
 
   def IsGroup(self):
     return True
 
+  def IterUniqueSymbols(self):
+    """Yields all symbols, but only one from each alias group."""
+    seen_aliases_lists = set()
+    for s in self:
+      if not s.aliases:
+        yield s
+      elif id(s.aliases) not in seen_aliases_lists:
+        seen_aliases_lists.add(id(s.aliases))
+        yield s
+
+  def IterLeafSymbols(self):
+    """Yields all symbols, recursing into subgroups."""
+    for s in self:
+      if s.IsGroup():
+        for x in s.IterLeafSymbols():
+          yield x
+      else:
+        yield s
+
+  def CountUniqueSymbols(self):
+    return sum(1 for s in self.IterUniqueSymbols())
+
   def _CreateTransformed(self, symbols, filtered_symbols=None, name=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,
                        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))
+      cmp_func = lambda a, b: cmp((a.IsBss(), abs(b.pss), a.name),
+                                  (b.IsBss(), abs(a.pss), b.name))
 
     after_symbols = sorted(self._symbols, cmp_func, key, reverse)
     return self._CreateTransformed(
         after_symbols, filtered_symbols=self._filtered_symbols,
         section_name=self.section_name, is_sorted=True)
 
   def SortedByName(self, reverse=False):
     return self.Sorted(key=(lambda s:s.name), reverse=reverse)
 
   def SortedByAddress(self, reverse=False):
-    return self.Sorted(key=(lambda s:s.address), reverse=reverse)
+    return self.Sorted(key=(lambda s:(s.address, s.object_path, s.name)),
+                       reverse=reverse)
 
   def SortedByCount(self, reverse=False):
     return self.Sorted(key=(lambda s:len(s) if s.IsGroup() else 1),
                        reverse=not reverse)
 
   def Filter(self, func):
     filtered_and_kept = ([], [])
     symbol = None
     try:
       for symbol in self:
@@ skipping 112 matching lines @@
     min_count = abs(min_count)
     for token, symbols in symbols_by_token.iteritems():
       if len(symbols) >= min_count:
         after_syms.append(self._CreateTransformed(
             symbols, name=token, section_name=self.section_name,
             is_sorted=False))
       elif include_singles:
         after_syms.extend(symbols)
       else:
         filtered_symbols.extend(symbols)
-    return self._CreateTransformed(
+    grouped = self._CreateTransformed(
         after_syms, filtered_symbols=filtered_symbols,
         section_name=self.section_name, is_sorted=False)
+    return grouped
 
   def GroupBySectionName(self):
     return self.GroupBy(lambda s: s.section_name)
 
   def GroupByNamespace(self, depth=0, fallback='{global}', min_count=0):
     """Groups by symbol namespace (as denoted by ::s).
 
     Does not differentiate between C++ namespaces and C++ classes.
 
     Args:
@@ skipping 14 matching lines @@
 
       # Remove after the final :: (not part of the namespace).
       colon_idx = name.rfind('::')
       if colon_idx == -1:
         return fallback
       name = name[:colon_idx]
 
       return _ExtractPrefixBeforeSeparator(name, '::', depth)
     return self.GroupBy(extract_namespace, min_count=min_count)
 
-  def GroupBySourcePath(self, depth=0, fallback='{no path}',
-                        fallback_to_object_path=True, min_count=0):
+  def GroupByPath(self, depth=0, fallback='{no path}',
+                  fallback_to_object_path=True, min_count=0):
     """Groups by source_path.
 
     Args:
       depth: When 0 (default), groups by entire path. When 1, groups by
              top-level directory, when 2, groups by top 2 directories, etc.
       fallback: Use this value when no namespace exists.
       fallback_to_object_path: When True (default), uses object_path when
              source_path is missing.
       min_count: Miniumum number of symbols for a group. If fewer than this many
                  symbols end up in a group, they will not be put within a group.
                  Use a negative value to omit symbols entirely rather than
                  include them outside of a group.
     """
     def extract_path(symbol):
       path = symbol.source_path
       if fallback_to_object_path and not path:
         path = symbol.object_path
       path = path or fallback
       return _ExtractPrefixBeforeSeparator(path, os.path.sep, depth)
     return self.GroupBy(extract_path, min_count=min_count)
 
-  def GroupByObjectPath(self, depth=0, fallback='{no path}', min_count=0):
-    """Groups by object_path.
-
-    Args:
-      depth: When 0 (default), groups by entire path. When 1, groups by
-             top-level directory, when 2, groups by top 2 directories, etc.
-      fallback: Use this value when no namespace exists.
-      min_count: Miniumum number of symbols for a group. If fewer than this many
-                 symbols end up in a group, they will not be put within a group.
-                 Use a negative value to omit symbols entirely rather than
-                 include them outside of a group.
-    """
-    def extract_path(symbol):
-      path = symbol.object_path or fallback
-      return _ExtractPrefixBeforeSeparator(path, os.path.sep, depth)
-    return self.GroupBy(extract_path, min_count=min_count)
-
 
 class SymbolDiff(SymbolGroup):
   """A SymbolGroup subclass representing a diff of two other SymbolGroups.
 
   All Symbols contained within have a |size| which is actually the size delta.
   Additionally, metadata is kept about which symbols were added / removed /
   changed.
   """
   __slots__ = (
       '_added_ids',
@@ skipping 88 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]