FREEZE.unindexed

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 37 matching lines @@
     'd': '.data',
     'r': '.rodata',
     't': '.text',
 }
 
 FLAG_ANONYMOUS = 1
 FLAG_STARTUP = 2
 FLAG_UNLIKELY = 4
 FLAG_REL = 8
 FLAG_REL_LOCAL = 16
+FLAG_GENERATED_SOURCE = 32
 
 
 class SizeInfo(object):
   """Represents all size information for a single binary.
 
   Fields:
     section_sizes: A dict of section_name -> size.
     symbols: A SymbolGroup containing all symbols, sorted by address.
     metadata: A dict.
   """
@@ skipping 61 matching lines @@
 
   @property
   def end_address(self):
     return self.address + self.size_without_padding
 
   @property
   def is_anonymous(self):
     return bool(self.flags & FLAG_ANONYMOUS)
 
   @property
+  def generated_source(self):
+    return bool(self.flags & FLAG_GENERATED_SOURCE)
+
+  @generated_source.setter
+  def generated_source(self, value):
+    if value:
+      self.flags |= FLAG_GENERATED_SOURCE
+    else:
+      self.flags &= ~FLAG_GENERATED_SOURCE
+
+  @property
   def num_aliases(self):
     return len(self.aliases) if self.aliases else 1
 
   def FlagsString(self):
     # Most flags are 0.
     flags = self.flags
     if not flags and not self.aliases:
       return '{}'
     parts = []
     if flags & FLAG_ANONYMOUS:
       parts.append('anon')
     if flags & FLAG_STARTUP:
       parts.append('startup')
     if flags & FLAG_UNLIKELY:
       parts.append('unlikely')
     if flags & FLAG_REL:
       parts.append('rel')
     if flags & FLAG_REL_LOCAL:
       parts.append('rel.loc')
+    if flags & FLAG_GENERATED_SOURCE:
+      parts.append('gen')
     # Not actually a part of flags, but useful to show it here.
     if self.aliases:
       parts.append('{} aliases'.format(self.num_aliases))
     return '{%s}' % ','.join(parts)
 
   def IsBss(self):
     return self.section_name == '.bss'
 
   def IsGroup(self):
     return False
 
-  def IsGenerated(self):
-    # TODO(agrieve): Also match generated functions such as:
-    #     startup._GLOBAL__sub_I_page_allocator.cc
-    return self.name.endswith(']') and not self.name.endswith('[]')
+  def IsGeneratedByToolchain(self):
+    return '.' in self.name or (
+        self.name.endswith(']') and not self.name.endswith('[]'))
 
 
 class Symbol(BaseSymbol):
   """Represents a single symbol within a binary.
 
   Refer to module docs for field descriptions.
   """
 
   __slots__ = (
       'address',
@@ skipping 112 matching lines @@
                                    section_name=self.section_name)
 
   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)
 
   @property
   def address(self):
-    first = self._symbols[0].address
+    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
+    first = self._symbols[0].flags if self else 0
     return first if all(s.flags == first for s in self._symbols) else 0
 
   @property
   def object_path(self):
-    first = self._symbols[0].object_path
+    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
+    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
@@ skipping 46 matching lines @@
     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 11 matching lines @@
 
   def WhereInSection(self, section):
     if len(section) == 1:
       ret = self.Filter(lambda s: s.section == section)
       ret.section_name = SECTION_TO_SECTION_NAME[section]
     else:
       ret = self.Filter(lambda s: s.section_name == section)
       ret.section_name = section
     return ret
 
-  def WhereIsGenerated(self):
-    return self.Filter(lambda s: s.IsGenerated())
+  def WhereSourceIsGenerated(self):
+    return self.Filter(lambda s: s.generated_source)
+
+  def WhereGeneratedByToolchain(self):
+    return self.Filter(lambda s: s.IsGeneratedByToolchain())
 
   def WhereNameMatches(self, pattern):
     regex = re.compile(match_util.ExpandRegexIdentifierPlaceholder(pattern))
     return self.Filter(lambda s: regex.search(s.name))
 
+  def WhereFullNameMatches(self, pattern):
+    regex = re.compile(match_util.ExpandRegexIdentifierPlaceholder(pattern))
+    return self.Filter(lambda s: regex.search(s.full_name or s.name))
+
   def WhereObjectPathMatches(self, pattern):
     regex = re.compile(match_util.ExpandRegexIdentifierPlaceholder(pattern))
     return self.Filter(lambda s: regex.search(s.object_path))
 
   def WhereSourcePathMatches(self, pattern):
     regex = re.compile(match_util.ExpandRegexIdentifierPlaceholder(pattern))
     return self.Filter(lambda s: regex.search(s.source_path))
 
   def WherePathMatches(self, pattern):
     regex = re.compile(match_util.ExpandRegexIdentifierPlaceholder(pattern))
@@ skipping 12 matching lines @@
     """Searches for addesses within [start, end).
 
     Args may be ints or hex strings. Default value for |end| is |start| + 1.
     """
     if isinstance(start, basestring):
       start = int(start, 16)
     if end is None:
       end = start + 1
     return self.Filter(lambda s: s.address >= start and s.address < end)
 
+  def WhereHasPath(self):
+    return self.Filter(lambda s: s.source_path or s.object_path)
+
   def WhereHasAnyAttribution(self):
     return self.Filter(lambda s: s.name or s.source_path or s.object_path)
 
   def Inverted(self):
     """Returns the symbols that were filtered out by the previous filter.
 
     Applies only when the previous call was a filter.
 
     Example:
         # Symbols that do not have "third_party" in their path.
@@ skipping 30 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)
+    # Grouping is rarely an intermediate step, so assume sorting is useful.
+    return grouped.Sorted()
 
   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]