diagnose_bloat.py: swap --silent with --verbose.

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 32 matching lines @@
 def _DiffPrefix(diff, sym):
   if diff.IsAdded(sym):
     return '+ '
   if diff.IsRemoved(sym):
     return '- '
   if sym.size:
     return '~ '
   return '= '
 
 
+def _Divide(a, b):
+  return float(a) / b if b else 0
+
+
 class Describer(object):
   def __init__(self, verbose=False, recursive=False):
     self.verbose = verbose
     self.recursive = recursive
 
   def _DescribeSectionSizes(self, section_sizes):
     relevant_names = models.SECTION_TO_SECTION_NAME.values()
     section_names = sorted(k for k in section_sizes.iterkeys()
                            if k in relevant_names or k.startswith('.data'))
     total_bytes = sum(v for k, v in section_sizes.iteritems()
                       if k in section_names and k != '.bss')
     yield ''
     yield 'Section Sizes (Total={} ({} bytes)):'.format(
         _PrettySize(total_bytes), total_bytes)
     for name in section_names:
       size = section_sizes[name]
       if name == '.bss':
         yield '    {}: {} ({} bytes) (not included in totals)'.format(
             name, _PrettySize(size), size)
       else:
-        percent = float(size) / total_bytes if total_bytes else 0
+        percent = _Divide(size, total_bytes)
         yield '    {}: {} ({} bytes) ({:.1%})'.format(
             name, _PrettySize(size), size, percent)
 
     if self.verbose:
       yield ''
       yield 'Other section sizes:'
       section_names = sorted(k for k in section_sizes.iterkeys()
                              if k not in section_names)
       for name in section_names:
         yield '    {}: {} ({} bytes)'.format(
@@ skipping 35 matching lines @@
     running_percent = 0
     is_diff = isinstance(group, models.SymbolDiff)
     all_groups = all(s.IsGroup() for s in group)
 
     indent_prefix = '> ' * indent
     diff_prefix = ''
     total = group.pss
     for index, s in enumerate(group):
       if group.IsBss() or not s.IsBss():
         running_total += s.pss
-        running_percent = running_total / total
+        running_percent = _Divide(running_total, total)
       for l in self._DescribeSymbol(s, single_line=all_groups):
         if l[:4].isspace():
           indent_size = 8 + len(indent_prefix) + len(diff_prefix)
           yield '{} {}'.format(' ' * indent_size, l)
         else:
           if is_diff:
             diff_prefix = _DiffPrefix(group, s)
           yield '{}{}{:<4} {:>8} {:7} {}'.format(
               indent_prefix, diff_prefix, str(index) + ')',
               _FormatPss(running_total), '({:.1%})'.format(running_percent), l)
@@ skipping 120 matching lines @@
       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]]
 
     # 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
+    size_percent = _Divide(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)
+        padding, _Divide(padding, in_section.size))
     if len(star_syms):
       yield ('* {} placeholders (symbols that start with **) account for '
              '{} bytes ({:.1%})').format(
                  len(star_syms), star_syms.size,
-                 float(star_syms.size) / in_section.size)
+                 _Divide(star_syms.size,  in_section.size))
     if anonymous_syms:
       yield '* {} anonymous symbols account for {} bytes ({:.1%})'.format(
           len(anonymous_syms), int(anonymous_syms.pss),
-          float(star_syms.size) / in_section.size)
+          _Divide(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')