Reland of V2 of //tools/binary_size rewrite (diffs).

tools/binary_size/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 symbols
-
-
-class ParseResult(object):
-  """Return value for Parse() methods."""
-  def __init__(self, symbol_list, section_sizes=None):
-    self.symbol_group = symbols.SymbolGroup(symbol_list)
-    self.section_sizes = section_sizes  # E.g. {'.text': 0}
+import models
 
 
 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._symbols = []
     self._section_sizes = {}
     self._lines = None
 
   def Parse(self, lines):
     """Parses a linker map file.
 
     Args:
       lines: Iterable of lines.
 
     Returns:
-      A ParseResult object.
+      A SizeInfo object.
     """
     self._lines = iter(lines)
     logging.info('Parsing common symbols')
     self._ParseCommonSymbols()
     logging.debug('.bss common entries: %d', len(self._symbols))
     logging.info('Parsing section symbols')
     self._ParseSections()
-    return ParseResult(self._symbols, self._section_sizes)
+    return models.SizeInfo(models.SymbolGroup(self._symbols),
+                           self._section_sizes)
 
   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
@@ skipping 13 matching lines @@
     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(
-          symbols.Symbol('.bss', 0, int(size_str[2:], 16), name, path))
+          models.Symbol('.bss',  int(size_str[2:], 16), name=name, path=path))
 
   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()
 #                 0x00290711                base::AutoLock::~AutoLock()
 # .text._ZNK5blink15LayoutBlockFlow31mustSeparateMarginAfterForChildERK...
 #                0xffffffffffffffff       0x46 obj/...
 #                0x006808e1                blink::LayoutBlockFlow::...
 # .bss
 #  .bss._ZGVZN11GrProcessor11initClassIDI10LightingFPEEvvE8kClassID
 #                0x02d4b294        0x4 obj/skia/skia/SkLightingShader.o
 #                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
@@ skipping 22 matching lines @@
                 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(
-                  symbols.Symbol(section_name, address, size, name, path))
+                  models.Symbol(section_name, size, address=address, name=name,
+                                path=path))
             else:
               # A normal symbol entry.
               subsection_name, address_str, size_str, path = (
                   self._ParsePossiblyWrappedParts(line, 4))
               size = int(size_str[2:], 16)
-              if address_str == '0xffffffffffffffff':
-                # The section needs special handling (e.g., a merge section)
-                # It also generally has a large offset after it, so don't
-                # penalize the subsequent symbol for this gap (e.g. a 50kb gap).
-                # TODO(agrieve): Learn more about why this happens.
-                address = -1
-                if syms and syms[-1].address > 0:
-                  merge_symbol_start_address = syms[-1].end_address
-                merge_symbol_start_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
-                  sym = symbols.Symbol(
-                      section_name, merge_symbol_start_address, merge_size,
-                      '** merged symbol: %s' % syms[-1].name, syms[-1].path)
-                  logging.debug('Merge symbol of size %d found at:\n  %r',
-                                merge_size, syms[-1])
-                  syms.append(sym)
-                  merge_symbol_start_address = 0
               assert subsection_name.startswith(section_name), (
                   'subsection name was: ' + subsection_name)
               mangled_name = subsection_name[prefix_len:]
               name = None
+              address_str2 = None
               while True:
                 line = next(self._lines).rstrip()
                 if not line or line.startswith(' .'):
                   break
                 # clang includes ** fill, but gcc does not.
                 if line.startswith(' ** fill'):
                   # Alignment explicitly recorded in map file. Rather than
                   # record padding based on these entries, we calculate it
                   # using addresses. We do this because fill lines are not
                   # present when compiling with gcc (only for clang).
                   continue
                 elif line.startswith(' **'):
                   break
                 elif name is None:
                   address_str2, name = self._ParsePossiblyWrappedParts(line, 2)
-                  if address == -1:
-                    address = int(address_str2[2:], 16) - 1
 
+              if address_str == '0xffffffffffffffff':
+                # The section needs special handling (e.g., a merge section)
+                # It also generally has a large offset after it, so don't
+                # penalize the subsequent symbol for this gap (e.g. a 50kb gap).
+                # There seems to be no corelation between where these gaps occur
+                # and the symbols they come in-between.
+                # TODO(agrieve): Learn more about why this happens.
+                address = -1
+                if syms and syms[-1].address > 0:
+                  merge_symbol_start_address = syms[-1].end_address
+                merge_symbol_start_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])
+                  sym = models.Symbol(
+                      section_name, merge_size,
+                      address=merge_symbol_start_address,
+                      name='** symbol gap %d' % symbol_gap_count, path=path)
+                  symbol_gap_count += 1
+                  syms.append(sym)
+                  merge_symbol_start_address = 0
+
+              if address == -1 and address_str2:
+                address = int(address_str2[2:], 16) - 1
               # Merge sym with no second line showing real address.
               if address == -1:
                 address = syms[-1].end_address
-              syms.append(symbols.Symbol(section_name, address, size,
-                                         name or mangled_name, path))
+              syms.append(models.Symbol(section_name, size, address=address,
+                                        name=name or mangled_name, path=path))
           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