supersize: Fix path counts, missing section in clusters

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 32 matching lines @@
 METADATA_GN_ARGS = 'gn_args'
 METADATA_TOOL_PREFIX = 'tool_prefix'  # Path relative to SRC_ROOT.
 
 
 SECTION_TO_SECTION_NAME = {
     'b': '.bss',
     'd': '.data',
     'r': '.rodata',
     't': '.text',
 }
+# Used by SymbolGroup when they contain a mix of sections.
+SECTION_NAME_MULTIPLE = '.*'
 
 FLAG_ANONYMOUS = 1
 FLAG_STARTUP = 2
 FLAG_UNLIKELY = 4
 FLAG_REL = 8
 FLAG_REL_LOCAL = 16
 FLAG_GENERATED_SOURCE = 32
 FLAG_CLONE = 64
 
 DIFF_STATUS_UNCHANGED = 0
@@ skipping 241 matching lines @@
   def __init__(self, symbols, filtered_symbols=None, full_name=None,
                template_name=None, name='', section_name=None, is_sorted=False):
     self._padding = None
     self._size = None
     self._pss = None
     self._symbols = symbols
     self._filtered_symbols = filtered_symbols or []
     self.full_name = full_name if full_name is not None else name
     self.template_name = template_name if template_name is not None else name
     self.name = name or ''
-    self.section_name = section_name or '.*'
+    self.section_name = section_name or SECTION_NAME_MULTIPLE
     self.is_sorted = is_sorted
 
   def __repr__(self):
     return 'Group(full_name=%s,count=%d,size=%d)' % (
         self.full_name, len(self), self.size)
 
   def __iter__(self):
     return iter(self._symbols)
 
   def __len__(self):
     return len(self._symbols)
 
   def __eq__(self, other):
     return isinstance(other, SymbolGroup) and self._symbols == other._symbols
 
   def __getitem__(self, key):
     """|key| can be an index or an address.
 
     Raises if multiple symbols map to the address.
     """
     if isinstance(key, slice):
-      return self._symbols.__getitem__(key)
+      return self._CreateTransformed(self._symbols.__getitem__(key))
     if isinstance(key, basestring) or key > len(self._symbols):
       found = self.WhereAddressInRange(key)
       if len(found) != 1:
         raise KeyError('%d symbols found at address %s.' % (len(found), key))
       return found[0]
     return self._symbols[key]
 
   def __sub__(self, other):
     other_ids = set(id(s) for s in other)
     after_symbols = [s for s in self if id(s) not in other_ids]
-    return self._CreateTransformed(after_symbols,
-                                   section_name=self.section_name)
+    return self._CreateTransformed(after_symbols)
 
   def __add__(self, other):
     self_ids = set(id(s) for s in self)
     after_symbols = self._symbols + [s for s in other if id(s) not in self_ids]
-    return self._CreateTransformed(
-        after_symbols, section_name=self.section_name, is_sorted=False)
+    return self._CreateTransformed(after_symbols, is_sorted=False)
 
   @property
   def address(self):
     first = self._symbols[0].address if self else 0
     return first if all(s.address == first for s in self._symbols) else 0
 
   @property
   def flags(self):
     first = self._symbols[0].flags if self else 0
     return first if all(s.flags == first for s in self._symbols) else 0
@@ skipping 64 matching lines @@
         yield s
 
   def CountUniqueSymbols(self):
     return sum(1 for s in self.IterUniqueSymbols())
 
   def _CreateTransformed(self, symbols, filtered_symbols=None, full_name=None,
                          template_name=None, name=None, section_name=None,
                          is_sorted=None):
     if is_sorted is None:
       is_sorted = self.is_sorted
+    if section_name is None:
+      section_name = self.section_name
     return SymbolGroup(symbols, filtered_symbols=filtered_symbols,
                        full_name=full_name, template_name=template_name,
                        name=name, section_name=section_name,
                        is_sorted=is_sorted)
 
   def Sorted(self, cmp_func=None, key=None, reverse=False):
     if cmp_func is None and key is None:
       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)
+        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, 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:
         filtered_and_kept[int(bool(func(symbol)))].append(symbol)
     except:
       logging.warning('Filter failed on symbol %r', symbol)
       raise
 
     return self._CreateTransformed(filtered_and_kept[1],
-                                   filtered_symbols=filtered_and_kept[0],
-                                   section_name=self.section_name)
+                                   filtered_symbols=filtered_and_kept[0])
 
   def WhereIsGroup(self):
     return self.Filter(lambda s: s.IsGroup())
 
   def WhereSizeBiggerThan(self, min_size):
     return self.Filter(lambda s: s.size >= min_size)
 
   def WherePssBiggerThan(self, min_pss):
     return self.Filter(lambda s: s.pss >= min_pss)
 
@@ skipping 72 matching lines @@
 
     Applies only when the previous call was a filter.
 
     Example:
         # Symbols that do not have "third_party" in their path.
         symbols.WherePathMatches(r'third_party').Inverted()
         # Symbols within third_party that do not contain the string "foo".
         symbols.WherePathMatches(r'third_party').WhereMatches('foo').Inverted()
     """
     return self._CreateTransformed(
-        self._filtered_symbols, filtered_symbols=self._symbols, is_sorted=False)
+        self._filtered_symbols, filtered_symbols=self._symbols,
+        section_name=SECTION_NAME_MULTIPLE, is_sorted=False)
 
   def GroupedBy(self, func, min_count=0, group_factory=None):
     """Returns a SymbolGroup of SymbolGroups, indexed by |func|.
 
     Symbols within each subgroup maintain their relative ordering.
 
     Args:
       func: Grouping function. Passed a symbol and returns a string for the
           name of the subgroup to put the symbol in. If None is returned, the
           symbol is omitted.
       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.
       group_factory: Function to create SymbolGroup from a list of Symbols.
     """
     if group_factory is None:
       group_factory = lambda token, symbols: self._CreateTransformed(
-            symbols, full_name=token, template_name=token, name=token,
-            section_name=self.section_name)
+            symbols, full_name=token, template_name=token, name=token)
 
     after_syms = []
     filtered_symbols = []
     symbols_by_token = collections.OrderedDict()
     # Index symbols by |func|.
     for symbol in self:
       token = func(symbol)
       if token is None:
         filtered_symbols.append(symbol)
       else:
@@ skipping 18 matching lines @@
           symbol_or_list = [symbol_or_list]
         after_syms.append(group_factory(token, symbol_or_list))
       else:
         target_list = after_syms if include_singles else filtered_symbols
         if count == 1:
           target_list.append(symbol_or_list)
         else:
           target_list.extend(symbol_or_list)
 
     return self._CreateTransformed(
-        after_syms, filtered_symbols=filtered_symbols,
-        section_name=self.section_name)
+        after_syms, filtered_symbols=filtered_symbols)
 
   def _Clustered(self):
     """Returns a new SymbolGroup with some symbols moved into subgroups.
 
     Method is private since it only ever makes sense to call it from
     SizeInfo.symbols.
 
     The main function of clustering is to put symbols that were broken into
     multiple parts under a group so that they once again look like a single
     symbol. It also groups together symbols like "** merge strings".
@@ skipping 221 matching lines @@
 
 
 def _ExtractSuffixAfterSeparator(string, separator, count):
   prev_idx = len(string) + 1
   for _ in xrange(count):
     idx = string.rfind(separator, 0, prev_idx - 1)
     if idx < 0:
       break
     prev_idx = idx
   return string[:prev_idx]