supersize: Add symbol.template_name, and strip <>s from symbol.name

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 61 matching lines @@
 #                     0x20000           obj/third_party/<snip>
     ret = []
     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,
+      sym = models.Symbol('.bss',  int(size_str[2:], 16), full_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
@@ skipping 59 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
               sym = models.Symbol(section_name, size, address=address,
-                                  name=name, object_path=path)
+                                  full_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
@@ skipping 38 matching lines @@
                   merge_size = address - merge_symbol_start_address
                   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)
+                        full_name='** symbol gap %d' % symbol_gap_count)
                     symbol_gap_count += 1
                     syms.append(sym)
 
               sym = models.Symbol(section_name, size, address=address,
-                                  name=name or mangled_name, object_path=path)
+                                  full_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)
+                full_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