Create a star symbol for gaps at the start & end of sections

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
@@ skipping 17 matching lines @@
   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._common_symbols = self._ParseCommonSymbols()
-    logging.debug('.bss common entries: %d', len(self._common_symbols))
-    logging.info('Parsing section symbols')
-    self._ParseSections()
+    logging.debug('Scanning for Header')
+
+    while True:
+      line = self._SkipToLineWithPrefix('Common symbol', 'Memory map')
+      if line.startswith('Common symbol'):
+        self._common_symbols = self._ParseCommonSymbols()
+        logging.debug('.bss common entries: %d', len(self._common_symbols))
+        continue
+      elif line.startswith('Memory map'):
+        self._ParseSections()
+      break
     return self._section_sizes, self._symbols
 
-  def _SkipToLineWithPrefix(self, prefix):
+  def _SkipToLineWithPrefix(self, prefix, prefix2=None):
     for l in self._lines:
-      if l.startswith(prefix):
+      if l.startswith(prefix) or (prefix2 and l.startswith(prefix2)):
         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
       sym = models.Symbol('.bss',  int(size_str[2:], 16), name=name,
                           object_path=path)
@@ skipping 19 matching lines @@
 #                0x02d4b294   guard variable for void GrProcessor::initClassID
 # .data           0x0028c600  0x22d3468
 #  .data.rel.ro._ZTVN3gvr7android19ScopedJavaGlobalRefIP12_jfloatArrayEE
 #                0x02d1e668       0x10 ../../third_party/.../libfoo.a(bar.o)
 #                0x02d1e668   vtable for gvr::android::GlobalRef<_jfloatArray*>
 #  ** merge strings
 #                 0x0255fb00   0x1f2424
 #  ** merge constants
 #                 0x0255fb00   0x8
 # ** common      0x02db5700   0x13ab48
-    self._SkipToLineWithPrefix('Memory map')
     syms = self._symbols
     symbol_gap_count = 0
     while True:
       line = self._SkipToLineWithPrefix('.')
       if not line:
         break
       section_name = None
       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)
+        section_name, section_address_str, section_size_str = parts
+        section_address = int(section_address_str[2:], 16)
+        section_size = int(section_size_str[2:], 16)
+        self._section_sizes[section_name] = section_size
         if (section_name in ('.bss', '.rodata', '.text') or
             section_name.startswith('.data')):
           logging.info('Parsing %s', section_name)
           if section_name == '.bss':
+            # Common symbols have no address.
             syms.extend(self._common_symbols)
           prefix_len = len(section_name) + 1  # + 1 for the trailing .
-          merge_symbol_start_address = 0
+          merge_symbol_start_address = section_address
           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.
@@ skipping 55 matching lines @@
                 else:
                   logging.warning('First symbol of section had address -1')
                   address = 0
 
                 merge_symbol_start_address = address + size
               else:
                 address = int(address_str[2:], 16)
                 # Finish off active address gap / merge section.
                 if merge_symbol_start_address:
                   merge_size = address - merge_symbol_start_address
-                  logging.debug('Merge symbol of size %d found at:\n  %r',
-                                merge_size, syms[-1])
-                  # 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
+                  if merge_size > 0:
+                    # merge_size == 0 for the initial symbol generally.
+                    logging.debug('Merge symbol of size %d found at:\n  %r',
+                                  merge_size, syms[-1])
+                    # 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)
 
               sym = models.Symbol(section_name, size, address=address,
                                   name=name or mangled_name, object_path=path)
               syms.append(sym)
+          section_end_address = section_address + section_size
+          if section_name != '.bss' and (
+              syms[-1].end_address < section_end_address):
+            # Set size=0 so that it will show up as padding.
+            sym = models.Symbol(
+                section_name, 0,
+                address=section_end_address,
+                name='** symbol gap %d (end of section)' % symbol_gap_count)
+            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