supersize: Track symbol aliases and shared symbols

tools/binary_size/libsupersize/linker_map_parser.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 logging
 
 import models
 
+# About linker maps:
+# * "Discarded input sections" include symbols merged with other symbols
+#   (aliases), so the information there is not actually a list of unused things.
+# * Linker maps include symbols that do not have names (with object path),
+#   whereas "nm" skips over these (they don't account for much though).
+# * The parse time for compressed linker maps is dominated by ungzipping.
+
 
 class MapFileParser(object):
   """Parses a linker map file (tested only on files from gold linker)."""
   # Map file writer for gold linker:
   # https://github.com/gittup/binutils/blob/HEAD/gold/mapfile.cc
 
   def __init__(self):
+    self._common_symbols = []
     self._symbols = []
     self._section_sizes = {}
     self._lines = None
 
   def Parse(self, lines):
     """Parses a linker map file.
 
     Args:
       lines: Iterable of lines.
 
     Returns:
       A tuple of (section_sizes, symbols).
     """
     self._lines = iter(lines)
     logging.info('Parsing common symbols')
-    self._ParseCommonSymbols()
-    logging.debug('.bss common entries: %d', len(self._symbols))
+    self._common_symbols = self._ParseCommonSymbols()
+    logging.debug('.bss common entries: %d', len(self._common_symbols))
     logging.info('Parsing section symbols')
     self._ParseSections()
     return self._section_sizes, self._symbols
 
   def _SkipToLineWithPrefix(self, prefix):
     for l in self._lines:
       if l.startswith(prefix):
         return l
 
   def _ParsePossiblyWrappedParts(self, line, count):
     parts = line.split(None, count - 1)
     if not parts:
       return None
     if len(parts) != count:
       line = next(self._lines)
       parts.extend(line.split(None, count - len(parts) - 1))
       assert len(parts) == count, 'parts: ' + ' '.join(parts)
     parts[-1] = parts[-1].rstrip()
     return parts
 
   def _ParseCommonSymbols(self):
 # Common symbol       size              file
 #
 # ff_cos_131072       0x40000           obj/third_party/<snip>
 # ff_cos_131072_fixed
 #                     0x20000           obj/third_party/<snip>
+    ret = []
     self._SkipToLineWithPrefix('Common symbol')
     next(self._lines)  # Skip past blank line
 
     name, size_str, path = None, None, None
     for l in self._lines:
       parts = self._ParsePossiblyWrappedParts(l, 3)
       if not parts:
         break
       name, size_str, path = parts
-      self._symbols.append(
-          models.Symbol('.bss',  int(size_str[2:], 16), name=name,
-                        object_path=path))
+      sym = models.Symbol('.bss',  int(size_str[2:], 16), name=name,
+                          object_path=path)
+      ret.append(sym)
+    return ret
 
   def _ParseSections(self):
 # .text           0x0028c600  0x22d3468
 #  .text.startup._GLOBAL__sub_I_bbr_sender.cc
 #                 0x0028c600       0x38 obj/net/net/bbr_sender.o
 #  .text._reset   0x00339d00       0xf0 obj/third_party/icu/icuuc/ucnv.o
 #  ** fill        0x0255fb00   0x02
 #  .text._ZN4base8AutoLockD2Ev
 #                 0x00290710        0xe obj/net/net/file_name.o
 #                 0x00290711                base::AutoLock::~AutoLock()
@@ skipping 25 matching lines @@
       try:
         # Parse section name and size.
         parts = self._ParsePossiblyWrappedParts(line, 3)
         if not parts:
           break
         section_name, address, size_str = parts
         self._section_sizes[section_name] = int(size_str[2:], 16)
         if (section_name in ('.bss', '.rodata', '.text') or
             section_name.startswith('.data')):
           logging.info('Parsing %s', section_name)
+          if section_name == '.bss':
+            syms.extend(self._common_symbols)
           prefix_len = len(section_name) + 1  # + 1 for the trailing .
           merge_symbol_start_address = 0
           sym_count_at_start = len(syms)
           line = next(self._lines)
           # Parse section symbols.
           while True:
             if not line or line.isspace():
               break
             if line.startswith(' **'):
               zero_index = line.find('0')
               if zero_index == -1:
                 # Line wraps.
                 name = line.strip()
                 line = next(self._lines)
               else:
                 # Line does not wrap.
                 name = line[:zero_index].strip()
                 line = line[zero_index:]
               address_str, size_str = self._ParsePossiblyWrappedParts(line, 2)
               line = next(self._lines)
               # These bytes are already accounted for.
               if name == '** common':
                 continue
               address = int(address_str[2:], 16)
               size = int(size_str[2:], 16)
               path = None
-              syms.append(
-                  models.Symbol(section_name, size, address=address, name=name,
-                                object_path=path))
+              sym = models.Symbol(section_name, size, address=address,
+                                  name=name, object_path=path)
+              syms.append(sym)
             else:
               # A normal symbol entry.
               subsection_name, address_str, size_str, path = (
                   self._ParsePossiblyWrappedParts(line, 4))
               size = int(size_str[2:], 16)
               assert subsection_name.startswith(section_name), (
                   'subsection name was: ' + subsection_name)
               mangled_name = subsection_name[prefix_len:]
               name = None
               address_str2 = None
@@ skipping 40 matching lines @@
                   # Set size=0 so that it will show up as padding.
                   sym = models.Symbol(
                       section_name, 0,
                       address=address,
                       name='** symbol gap %d' % symbol_gap_count,
                       object_path=path)
                   symbol_gap_count += 1
                   syms.append(sym)
                   merge_symbol_start_address = 0
 
-              syms.append(models.Symbol(section_name, size, address=address,
-                                        name=name or mangled_name,
-                                        object_path=path))
+              sym = models.Symbol(section_name, size, address=address,
+                                  name=name or mangled_name, object_path=path)
+              syms.append(sym)
           logging.debug('Symbol count for %s: %d', section_name,
                         len(syms) - sym_count_at_start)
       except:
         logging.error('Problem line: %r', line)
         logging.error('In section: %r', section_name)
         raise