supersize: Strip linker-added prefixes from symbol names

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 29 matching lines @@
 METADATA_GN_ARGS = 'gn_args'
 
 
 SECTION_TO_SECTION_NAME = {
     'b': '.bss',
     'd': '.data',
     'r': '.rodata',
     't': '.text',
 }
 
+FLAG_ANONYMOUS = 1
+FLAG_STARTUP = 2
+FLAG_UNLIKELY = 4
+FLAG_REL = 8
+FLAG_REL_LOCAL = 16
+
 
 class SizeInfo(object):
   """Represents all size information for a single binary.
 
   Fields:
     section_sizes: A dict of section_name -> size.
     raw_symbols: A flat list of all symbols.
     symbols: A SymbolGroup containing raw_symbols, but with some Symbols grouped
         into sub-SymbolGroups.
     metadata: A dict.
@@ skipping 55 matching lines @@
     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
 
+  @property
+  def is_anonymous(self):
+    return bool(self.flags & FLAG_ANONYMOUS)
+
+  def FlagsString(self):
+    # Most flags are 0.
+    flags = self.flags
+    if not flags:
+      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')
+    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('[]')
@@ skipping 14 matching lines @@
 
 class Symbol(BaseSymbol):
   """Represents a single symbol within a binary.
 
   Refer to module docs for field descriptions.
   """
 
   __slots__ = (
       'address',
       'full_name',
-      'is_anonymous',
+      'flags',
       'object_path',
       'name',
       'padding',
       'section_name',
       'source_path',
       'size',
   )
 
   def __init__(self, section_name, size_without_padding, address=None,
-               name=None, source_path=None, object_path=None,
-               full_name=None, is_anonymous=False):
+               name=None, source_path=None, object_path=None, full_name=None,
+               flags=0):
     self.section_name = section_name
     self.address = address or 0
     self.name = name or ''
     self.full_name = full_name or ''
     self.source_path = source_path or ''
     self.object_path = object_path or ''
     self.size = size_without_padding
-    # Change this to be a bitfield of flags if ever there is a need to add
-    # another similar thing.
-    self.is_anonymous = is_anonymous
+    self.flags = flags
     self.padding = 0
 
   def __repr__(self):
-    return ('%s@%x(size_without_padding=%d,padding=%d,name=%s,path=%s,anon=%d)'
+    return ('%s@%x(size_without_padding=%d,padding=%d,name=%s,path=%s,flags=%s)'
             % (self.section_name, self.address, self.size_without_padding,
                self.padding, self.name, self.source_path or self.object_path,
-               int(self.is_anonymous)))
+               self.FlagsString()))
 
 
 class SymbolGroup(BaseSymbol):
   """Represents a group of symbols using the same interface as Symbol.
 
   SymbolGroups are immutable. All filtering / sorting will return new
   SymbolGroups objects.
 
   Overrides many __functions__. E.g. the following are all valid:
   * len(group)
@@ skipping 64 matching lines @@
     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
     return first if all(s.address == first for s in self._symbols) else 0
 
   @property
-  def is_anonymous(self):
-    first = self._symbols[0].is_anonymous
-    return first if all(
-        s.is_anonymous == first for s in self._symbols) else False
+  def flags(self):
+    first = self._symbols[0].flags
+    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
     return first if all(s.object_path == first for s in self._symbols) else None
 
   @property
   def source_path(self):
     first = self._symbols[0].source_path
     return first if all(s.source_path == first for s in self._symbols) else None
@@ skipping 358 matching lines @@
       if before_sym.IsGroup() and after_sym.IsGroup():
         merged_sym = _DiffSymbols(before_sym, after_sym)
       else:
         size_diff = (after_sym.size_without_padding -
                      before_sym.size_without_padding)
         merged_sym = Symbol(after_sym.section_name, size_diff,
                             address=after_sym.address, name=after_sym.name,
                             source_path=after_sym.source_path,
                             object_path=after_sym.object_path,
                             full_name=after_sym.full_name,
-                            is_anonymous=after_sym.is_anonymous)
+                            flags=after_sym.flags)
 
         # Diffs are more stable when comparing size without padding, except when
         # the symbol is a padding-only symbol.
         if after_sym.size_without_padding == 0 and size_diff == 0:
           merged_sym.padding = after_sym.padding - before_sym.padding
         else:
           padding_by_section_name[after_sym.section_name] += (
               after_sym.padding - before_sym.padding)
 
       similar.append(merged_sym)
@@ skipping 16 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]