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

tools/binary_size/libsupersize/describe.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.
 """Methods for converting model objects to human-readable formats."""
 
 import datetime
 import itertools
 import time
 
 import models
@@ skipping 75 matching lines @@
       address = hex(sym.address)
     if self.verbose:
       count_part = '  count=%d' % len(sym) if sym.IsGroup() else ''
       yield '{}@{:<9s}  pss={}  padding={}  size_without_padding={}{}'.format(
           sym.section, address, _FormatPss(sym.pss), sym.padding,
           sym.size_without_padding, count_part)
       yield '    source_path={} \tobject_path={}'.format(
           sym.source_path, sym.object_path)
       if sym.name:
         yield '    flags={}  name={}'.format(sym.FlagsString(), sym.name)
-        if sym.full_name:
+        if sym.full_name is not sym.name:
           yield '         full_name={}'.format(sym.full_name)
       elif sym.full_name:
         yield '    flags={}  full_name={}'.format(
             sym.FlagsString(), sym.full_name)
     elif single_line:
       count_part = ' (count=%d)' % len(sym) if sym.IsGroup() else ''
       yield '{}@{:<9s}  {:<7} {}{}'.format(
           sym.section, address, _FormatPss(sym.pss), sym.name, count_part)
     else:
       yield '{}@{:<9s}  {:<7} {}'.format(
@@ skipping 139 matching lines @@
 def DescribeSizeInfoCoverage(size_info):
   """Yields lines describing how accurate |size_info| is."""
   for section in models.SECTION_TO_SECTION_NAME:
     if section == 'd':
       expected_size = sum(v for k, v in size_info.section_sizes.iteritems()
                           if k.startswith('.data'))
     else:
       expected_size = size_info.section_sizes[
           models.SECTION_TO_SECTION_NAME[section]]
 
-
-    in_section = size_info.symbols.WhereInSection(section)
+    # Use raw_symbols in case symbols contains groups.
+    in_section = models.SymbolGroup(size_info.raw_symbols).WhereInSection(
+        section)
     actual_size = in_section.size
     size_percent = float(actual_size) / expected_size
     yield ('Section {}: has {:.1%} of {} bytes accounted for from '
            '{} symbols. {} bytes are unaccounted for.').format(
                section, size_percent, actual_size, len(in_section),
                expected_size - actual_size)
     star_syms = in_section.WhereNameMatches(r'^\*')
     padding = in_section.padding - star_syms.padding
     anonymous_syms = star_syms.Inverted().WhereHasAnyAttribution().Inverted()
     yield '* Padding accounts for {} bytes ({:.1%})'.format(
         padding, float(padding) / in_section.size)
     if len(star_syms):
       yield ('* {} placeholders (symbols that start with **) account for '
              '{} bytes ({:.1%})').format(
-                 len(star_syms), star_syms.pss, star_syms.pss / in_section.size)
+                 len(star_syms), star_syms.size,
+                 float(star_syms.size) / in_section.size)
     if anonymous_syms:
       yield '* {} anonymous symbols account for {} bytes ({:.1%})'.format(
           len(anonymous_syms), int(anonymous_syms.pss),
-          star_syms.pss / in_section.size)
+          float(star_syms.size) / in_section.size)
 
     aliased_symbols = in_section.Filter(lambda s: s.aliases)
     if section == 't':
       if len(aliased_symbols):
         uniques = sum(1 for s in aliased_symbols.IterUniqueSymbols())
         yield ('* Contains {} aliases, mapped to {} unique addresses '
                '({} bytes)').format(
                    len(aliased_symbols), uniques, aliased_symbols.size)
       else:
         yield '* Contains 0 aliases'
@@ skipping 29 matching lines @@
 
 def GenerateLines(obj, verbose=False, recursive=False):
   """Returns an iterable of lines (without \n) that describes |obj|."""
   return Describer(verbose=verbose, recursive=recursive).GenerateLines(obj)
 
 
 def WriteLines(lines, func):
   for l in lines:
     func(l)
     func('\n')