Supersize: Store whether source path was generated in flags

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

[estevenson, 2017/05/05 19:14:58]

probably obvious but what is the "if self" for?

[agrieve, 2017/05/06 00:37:29]

it checks for the case of a SymbolGroup with no children.

     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 92 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):

[estevenson, 2017/05/05 19:14:58]

Does it make sense to just add this to WhereNameMatches above?

[agrieve, 2017/05/06 00:37:29]

This is certainly a place where I'm not sure what the right API should really
look like, and that working on analyzing some templates might make it become
more clear.

Nothing's using this at the moment, but I wanted for a manual query I ran so
just left it in.

Going to just stick with it for now, but happy to discuss later changes to these
things.

+    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.
         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)
 
   def GroupBy(self, func, min_count=0):
     """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.
     """
     after_syms = []
@@ skipping 195 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]