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

tools/binary_size/libsupersize/diff.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.
 """Logic for diffing two SizeInfo objects."""
 
 import collections
 import re
 
 import models
 
 
 def _SymbolKey(symbol):
   """Returns a tuple that can be used to see if two Symbol are the same.
 
   Keys are not guaranteed to be unique within a SymbolGroup. When multiple
   symbols have the same key, they will be matched up in order of appearance.
   We do this because the numbering of these generated symbols is not stable.
 
   Examples of symbols with shared keys:
     "** merge strings"
     "** symbol gap 3", "** symbol gap 5"
     "foo() [clone ##]"
     "CSWTCH.61", "CSWTCH.62"
     "._468", "._467"
     ".L__unnamed_1193", ".L__unnamed_712"
   """
-  name = symbol.full_name or symbol.name
+  name = symbol.full_name
   clone_idx = name.find(' [clone ')
   if clone_idx != -1:
     name = name[:clone_idx]
   if name.startswith('*'):
     # "symbol gap 3 (bar)" -> "symbol gaps"
     name = re.sub(r'\s+\d+( \(.*\))?$', 's', name)
 
   if '.' not in name:
     return (symbol.section_name, name)
   # Compiler or Linker generated symbol.
   name = re.sub(r'[.0-9]', '', name)  # Strip out all numbers and dots.
   return (symbol.section_name, name, symbol.object_path)
 
 
 def _CloneSymbol(sym, size):
   """Returns a copy of |sym| with an updated |size|.
 
   Padding and aliases are not copied.
   """
   return models.Symbol(
-      sym.section_name, size, address=sym.address, name=sym.name,
-      source_path=sym.source_path, object_path=sym.object_path,
-      full_name=sym.full_name, flags=sym.flags)
+      sym.section_name, size, address=sym.address, full_name=sym.full_name,
+      template_name=sym.template_name, name=sym.name,
+      source_path=sym.source_path, object_path=sym.object_path, flags=sym.flags)
 
 
 def _CloneAlias(sym, diffed_alias):
   """Returns a copy of |sym| and making it an alias of |diffed_alias|."""
   ret = _CloneSymbol(sym, diffed_alias.size_without_padding)
   ret.padding = diffed_alias.padding
   ret.aliases = diffed_alias.aliases
   ret.aliases.append(ret)
   return ret
 
@@ skipping 107 matching lines @@
   for remaining_syms in before_symbols_by_key.itervalues():
     removed.extend(_NegateAndClone(remaining_syms, matched_before_aliases,
                                    negated_symbol_by_before_aliases))
 
   # Step 4: Create ** symbols to represent padding differences.
   for section_name, padding in padding_by_section_name.iteritems():
     if padding != 0:
       similar.append(models.Symbol(
           section_name, padding,
           name="** aggregate padding of diff'ed symbols"))
-  return models.SymbolDiff(
-      added, removed, similar, name=after.name, full_name=after.full_name,
-      section_name=after.section_name)
+  return models.SymbolDiff(added, removed, similar)
 
 
 def Diff(before, after):
   """Diffs two SizeInfo objects. Returns a SizeInfoDiff."""
   assert isinstance(before, models.SizeInfo)
   assert isinstance(after, models.SizeInfo)
   section_sizes = {k: after.section_sizes[k] - v
                    for k, v in before.section_sizes.iteritems()}
   symbol_diff = _DiffSymbolGroups(before.symbols, after.symbols)
   return models.SizeInfoDiff(section_sizes, symbol_diff, before.metadata,
                              after.metadata)