//tools/binary_size: source_path information, change file format, fixes

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 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 SizeInfo object.
+      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))
     logging.info('Parsing section symbols')
     self._ParseSections()
-    return models.SizeInfo(models.SymbolGroup(self._symbols),
-                           self._section_sizes)
+    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
@@ 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(
-          models.Symbol('.bss',  int(size_str[2:], 16), name=name, path=path))
+          models.Symbol('.bss',  int(size_str[2:], 16), name=name,
+                        object_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()
@@ skipping 53 matching lines @@
               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,
-                                path=path))
+                                object_path=path))
             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 27 matching lines @@
               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)
+                      name='** symbol gap %d' % symbol_gap_count,
+                      object_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(models.Symbol(section_name, size, address=address,
-                                        name=name or mangled_name, path=path))
+                                        name=name or mangled_name,
+                                        object_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