V1 of //tools/binary_size rewrite

tools/binary_size/symbols.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.
+
+import collections
+import re
+
+
+SECTION_TO_SECTION_NAME = {
+    'b': '.bss',
+    'd': '.data',
+    'r': '.rodata',
+    't': '.text',
+}
+
+
+class BaseSymbol(object):
+  """Base class for Symbol and SymbolGroup."""
+  __slots__ = ()
+
+  def __repr__(self):
+    return '%s@%x(size=%d,padding=%d,name=%s,path=%s)' % (
+        self.section_name, self.address, self.size_without_padding,
+        self.size - self.size_without_padding, self.name, self.path)
+
+  @property
+  def section(self):
+    return self.section_name[1]
+
+  @property
+  def size_without_padding(self):
+    return self.size - self.padding
+
+  @property
+  def end_address(self):
+    return self.address + self.size_without_padding
+
+  def IsGroup(self):
+    return False
+
+  def IsGenerated(self):
+    return self.name and self.name.endswith(']') and (
+        not self.name.endswith('[]'))
+
+
+class Symbol(BaseSymbol):
+  """Represents a single symbol within a binary."""
+
+  __slots__ = (
+      'section_name',
+      'address',
+      'size',
+      'padding',
+      'name',
+      'function_signature',
+      'path',
+  )
+
+  def __init__(self, section_name, address, size_without_padding, name, path):
+    self.section_name = intern(section_name)
+    self.address = address
+    self.size = size_without_padding
+    self.padding = 0
+    self.name = name
+    self.function_signature = None
+    self.path = path
+
+
+class SymbolGroup(BaseSymbol):
+  """Represents a group of symbols using the same interface as Symbol."""
+
+  __slots__ = (
+      'symbols',
+      'filtered_symbols',
+      'name',
+      'section_name',
+  )
+
+  def __init__(self, symbols, filtered_symbols=None, name=None,
+               section_name='**'):
+    self.symbols = symbols
+    self.filtered_symbols = filtered_symbols or []
+    self.name = name
+    self.section_name = section_name
+
+  @property
+  def address(self):
+    return 0
+
+  @property
+  def function_signature(self):
+    return None
+
+  @property
+  def path(self):
+    return None
+
+  @property
+  def size(self):
+    return sum(s.size for s in self)
+
+  @property
+  def padding(self):
+    return sum(s.padding for s in self)
+
+  def __iter__(self):
+    return iter(self.symbols)
+
+  def __len__(self):
+    return len(self.symbols)
+
+  def IsGroup(self):
+    return True
+
+  def Sorted(self, cmp_func=None, key=None, reverse=False):
+    # Default to sorting by size then name.
+    if cmp_func is None and key is None:
+      cmp_func = lambda a, b: cmp((b.size, a.name), (a.size, b.name))
+
+    new_symbols = sorted(self.symbols, cmp_func, key, reverse)
+    return self.__class__(new_symbols, filtered_symbols=self.filtered_symbols,

[estevenson, 2017/03/16 19:49:18]

Any reason you're using __class__ instead of SymbolGroup()?

[agrieve, 2017/03/20 19:58:08]

I'm debating adding a chromium-specific SymbolGroup subclass that will have a
"GroupByChromiumComponent".

It might also be nice to figure out if we can separate the filtering logic from
SymbolGroup without losing nice syntax. hmm...

+                          section_name=self.section_name)
+
+  def Filter(self, func, include_filtered=False):
+    filtered_and_kept = ([], [])
+    for symbol in self:
+      filtered_and_kept[int(bool(func(symbol)))].append(symbol)
+
+    if include_filtered:
+      filtered_and_kept[0].extend(self.filtered_symbols)
+    return self.__class__(filtered_and_kept[1],
+                          filtered_symbols=filtered_and_kept[0],
+                          section_name=self.section_name)
+
+  def WhereBiggerThan(self, min_size, include_filtered=False):
+    return self.Filter(lambda s: s.size >= min_size,
+                       include_filtered=include_filtered)
+
+  def WhereInSection(self, section, include_filtered=False):
+    ret = self.Filter(lambda s: s.section == section,
+                      include_filtered=include_filtered)
+    ret.section_name = SECTION_TO_SECTION_NAME[section]
+    return ret
+
+  def WhereNameMatches(self, pattern, include_filtered=False):
+    regex = re.compile(pattern)
+    return self.Filter(lambda s: s.name and regex.search(s.name),
+                       include_filtered=include_filtered)
+
+  def WherePathMatches(self, pattern, include_filtered=False):
+    regex = re.compile(pattern)
+    return self.Filter(lambda s: s.path and regex.search(s.path),
+                       include_filtered=include_filtered)
+
+  def WhereHasAnyAttribution(self, include_filtered=False):
+    return self.Filter(lambda s: s.name or s.path,
+                       include_filtered=include_filtered)
+
+  def Inverted(self):
+    return self.__class__(self.filtered_symbols, filtered_symbols=self.symbols)
+
+  def GroupBy(self, func, include_filtered=False):
+    new_syms = []
+    filtered_symbols = []
+    symbols_by_name = collections.defaultdict(list)
+    for symbol in self:
+      name = func(symbol)
+      if not name:
+        filtered_symbols.append(symbol)
+        continue
+      symbols_by_name[name].append(symbol)
+    for name, symbols in symbols_by_name.iteritems():
+      new_syms.append(self.__class__(symbols, name=name,
+                                     section_name=self.section_name))
+    if include_filtered:
+      filtered_symbols.extend(self.filtered_symbols)
+    return self.__class__(new_syms, filtered_symbols=filtered_symbols,
+                          section_name=self.section_name)
+
+  def GroupByNamespace(self, include_filtered=False):
+    def extract_namespace(symbol):
+      # Does not distinguish between classes and namespaces.
+      if symbol.name:
+        sep_index = symbol.name.find('::')
+        if sep_index != -1:
+          ret = symbol.name[0:sep_index]
+          if '<' not in ret:
+            return ret
+      return '{global}'
+    return self.GroupBy(extract_namespace, include_filtered=include_filtered)
+
+  def GroupByPath(self, depth=1, include_filtered=False):
+    def extract_path(symbol):
+      if symbol.path:
+        idx = -1
+        for _ in xrange(depth):
+          idx = symbol.path.find('/', idx + 1)
+        if idx != -1:
+          return symbol.path[:idx]
+      return None
+    return self.GroupBy(extract_path, include_filtered=include_filtered)