Create a star symbol for gaps at the start & end of sections

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 210 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]]
 
-    def one_stat(group):
-      template = ('Section {}: has {:.1%} of {} bytes accounted for from '
-                  '{} symbols. {} bytes are unaccounted for.')
-      actual_size = group.size
-      size_percent = float(actual_size) / expected_size
-      return template.format(section, size_percent, actual_size, len(group),
-                             expected_size - actual_size)
 
     in_section = size_info.symbols.WhereInSection(section)
-    yield one_stat(in_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(
-        in_section.padding, float(in_section.padding) / in_section.size)
+        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)
+    if anonymous_syms:
+      yield '* {} anonymous symbols account for {} bytes ({:.1%})'.format(
+          len(anonymous_syms), int(anonymous_syms.pss),
+          star_syms.pss / in_section.size)
 
     aliased_symbols = in_section.Filter(lambda s: s.aliases)
-    if len(aliased_symbols):
-      uniques = sum(1 for s in aliased_symbols.IterUniqueSymbols())
-      yield '* Contains {} aliases, mapped to {} addresses ({} bytes)'.format(
-          len(aliased_symbols), uniques, aliased_symbols.size)
-    else:
-      yield '* Contains 0 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'
 
     inlined_symbols = in_section.WhereObjectPathMatches('{shared}')
     if len(inlined_symbols):
       yield '* {} symbols have shared ownership ({} bytes)'.format(
           len(inlined_symbols), inlined_symbols.size)
     else:
       yield '* 0 symbols have shared ownership'
 
-    star_syms = in_section.WhereNameMatches(r'^\*')
-    attributed_syms = star_syms.Inverted().WhereHasAnyAttribution()
-    anonymous_syms = attributed_syms.Inverted()
-    if star_syms or anonymous_syms:
-      missing_size = star_syms.pss + anonymous_syms.pss
-      anon_str = ''
-      if len(anonymous_syms):
-        anon_str = 'and {} anonymous entries '.format(len(anonymous_syms))
-      yield '* Without {} merge sections {}(accounting for {} bytes):'.format(
-          len(star_syms), anon_str, int(missing_size))
-      yield '  * ' + one_stat(attributed_syms)
 
 
 def _UtcToLocal(utc):
   epoch = time.mktime(utc.timetuple())
   offset = (datetime.datetime.fromtimestamp(epoch) -
             datetime.datetime.utcfromtimestamp(epoch))
   return utc + offset
 
 
 def DescribeMetadata(metadata):
@@ skipping 11 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')