supersize: Add "printed" to console, Show ~0 for PSS >0 <.1

tools/binary_size/libsupersize/console.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.
 
 """An interactive console for looking analyzing .size files."""
 
 import argparse
 import atexit
 import code
 import contextlib
@@ skipping 49 matching lines @@
     with open(to_file, 'w') as file_obj:
       describe.WriteLines(lines, file_obj.write)
   else:
     describe.WriteLines(lines, sys.stdout.write)
 
 
 class _Session(object):
   _readline_initialized = False
 
   def __init__(self, size_infos, size_paths, lazy_paths):
+    self._printed_variables = []
     self._variables = {
         'Print': self._PrintFunc,
         'Diff': self._DiffFunc,
         'Disassemble': self._DisassembleFunc,
         'ExpandRegex': match_util.ExpandRegexIdentifierPlaceholder,
         'ShowExamples': self._ShowExamplesFunc,
         'canned_queries': canned_queries.CannedQueries(size_infos),
+        'printed': self._printed_variables,
     }
     self._lazy_paths = lazy_paths
     self._size_infos = size_infos
     self._size_paths = size_paths
     self._disassemble_prefix_len = None
 
     if len(size_infos) == 1:
       self._variables['size_info'] = size_infos[0]
     else:
       for i, size_info in enumerate(size_infos):
@@ skipping 15 matching lines @@
     if cluster:
       ret.symbols = ret.symbols.Clustered()
     if sort:
       ret.symbols = ret.symbols.Sorted()
     return ret
 
   def _PrintFunc(self, obj=None, verbose=False, recursive=False, use_pager=None,
                  to_file=None):
     """Prints out the given Symbol / SymbolGroup / SymbolDiff / SizeInfo.
 
+    For convenience, |obj| will be appended to the global "printed" list.
+
     Args:
       obj: The object to be printed. Defaults to size_infos[-1].
       verbose: Show more detailed output.
       recursive: Print children of nested SymbolGroups.
       use_pager: Pipe output through `less`. Ignored when |obj| is a Symbol.
           default is to automatically pipe when output is long.
       to_file: Rather than print to stdio, write to the given file.
     """
+    if not self._printed_variables or self._printed_variables[-1] != obj:
+      self._printed_variables.append(obj)
     obj = obj if obj is not None else self._size_infos[-1]
     lines = describe.GenerateLines(obj, verbose=verbose, recursive=recursive)
     _WriteToStream(lines, use_pager=use_pager, to_file=to_file)
 
   def _ElfPathAndToolPrefixForSymbol(self, symbol, elf_path, tool_prefix):
     size_info = None
     size_path = None
     for size_info, size_path in zip(self._size_infos, self._size_paths):
       if symbol in size_info.symbols:
         break
@@ skipping 59 matching lines @@
 
   def _DisassembleFunc(self, symbol, elf_path=None, use_pager=None,
                        to_file=None):
     """Shows objdump disassembly for the given symbol.
 
     Args:
       symbol: Must be a .text symbol and not a SymbolGroup.
       elf_path: Path to the executable containing the symbol. Required only
           when auto-detection fails.
     """
+    assert not symbol.IsGroup()
     assert symbol.address and symbol.section_name == '.text'
 
     tool_prefix = self._lazy_paths.tool_prefix
     if not elf_path:
       elf_path, tool_prefix = self._ElfPathAndToolPrefixForSymbol(
           symbol, elf_path, tool_prefix)
 
     args = [tool_prefix + 'objdump', '--disassemble', '--source',
             '--line-numbers', '--demangle',
             '--start-address=0x%x' % symbol.address,
@@ skipping 31 matching lines @@
         'help(models)',
         '',
         '# Show all attributes of all symbols & per-section totals:',
         'Print(size_info, verbose=True)',
         '',
         '# Show two levels of .text, grouped by first two subdirectories',
         'text_syms = size_info.symbols.WhereInSection("t")',
         'by_path = text_syms.GroupedByPath(depth=2)',
         'Print(by_path.WherePssBiggerThan(1024))',
         '',
-        '# Show all non-vtable generated symbols',
-        'generated_syms = size_info.symbols.WhereGeneratedByToolchain()',
-        'Print(generated_syms.WhereNameMatches(r"vtable").Inverted().Sorted())',
+        '# Show all generated symbols, then show only non-vtable ones',
+        'Print(size_info.symbols.WhereGeneratedByToolchain())',
+        'Print(printed[-1].WhereNameMatches(r"vtable").Inverted().Sorted())',
         '',
         '# Show all symbols that have "print" in their name or path, except',
         '# those within components/.',
         '# Note: Could have also used Inverted(), as above.',
         '# Note: Use "help(ExpandRegex)" for more about what {{_print_}} does.',
         'print_syms = size_info.symbols.WhereMatches(r"{{_print_}}")',
         'Print(print_syms - print_syms.WherePathMatches(r"^components/"))',
         '',
         '# Diff two .size files and save result to a file:',
         'Print(Diff(size_info1, size_info2), to_file="output.txt")',
@@ skipping 85 matching lines @@
                                output_directory=args.output_directory,
                                any_path_within_output_directory=args.inputs[0])
   session = _Session(size_infos, args.inputs, lazy_paths)
 
   if args.query:
     logging.info('Running query from command-line.')
     session.Eval(args.query)
   else:
     logging.info('Entering interactive console.')
     session.GoInteractive()